[mediacontroller] Add display mode abilities

[ACR]
http://suprem.sec.samsung.net/jira/browse/TWDAPI-233

[Verification]
tct-mediacontroller-tizen-tests 100% PASS
tested manually on chrome console

Change-Id: I816d97c38f0ce4fe2f894da1672b748a491cc913
Signed-off-by: Dawid Juszczak <d.juszczak@samsung.com>

diff --git a/src/mediacontroller/mediacontroller_api.js b/src/mediacontroller/mediacontroller_api.js
index 06ef8ee..f0732f4 100755 (executable)
--- a/src/mediacontroller/mediacontroller_api.js
+++ b/src/mediacontroller/mediacontroller_api.js
@@ -259,6 +259,13 @@ var ClientAbilityChangeListener = new ListenerManager(
                 new MediaControllerPlaybackAbilitiesInfo(msg.name)
             );
         }
+        if (msg.action === 'ondisplaymodeabilitychanged') {
+            native_.callIfPossible(
+                listener[msg.action],
+                new MediaControllerServerInfo(msg),
+                new MediaControllerDisplayModeAbilitiesInfo(msg.name)
+            );
+        }
         if (msg.action === 'onsimpleabilitychanged') {
             native_.callIfPossible(
                 listener[msg.action],
@@ -650,6 +657,10 @@ var MediaControllerAbilities = function() {
             value: new MediaControllerPlaybackAbilities(),
             enumerable: true
         },
+        displayMode: {
+            value: new MediaControllerDisplayModeAbilities(),
+            enumerable: true
+        },
         playbackPosition: {
             get: function() {
                 return _playbackPosition;
@@ -864,6 +875,73 @@ var MediaControllerPlaybackAbilities = function() {
     };
 };
 
+var MediaControllerDisplayModeAbilities = function() {
+    var _letterBox = MediaControllerAbilitySupport.NO,
+        _originSize = MediaControllerAbilitySupport.NO,
+        _fullScreen = MediaControllerAbilitySupport.NO,
+        _croppedFull = MediaControllerAbilitySupport.NO;
+
+    Object.defineProperties(this, {
+        letterBox: {
+            get: function() {
+                return _letterBox;
+            },
+            set: function(val) {
+                if (val !== _letterBox) {
+                    setDisplayModeAbility(MediaControllerDisplayModeType.LETTER_BOX, val);
+                    _letterBox = val;
+                }
+            },
+            enumerable: true
+        },
+        originSize: {
+            get: function() {
+                return _originSize;
+            },
+            set: function(val) {
+                if (val !== _originSize) {
+                    setDisplayModeAbility(
+                        MediaControllerDisplayModeType.ORIGIN_SIZE,
+                        val
+                    );
+                    _originSize = val;
+                }
+            },
+            enumerable: true
+        },
+        fullScreen: {
+            get: function() {
+                return _fullScreen;
+            },
+            set: function(val) {
+                if (val !== _fullScreen) {
+                    setDisplayModeAbility(
+                        MediaControllerDisplayModeType.FULL_SCREEN,
+                        val
+                    );
+                    _fullScreen = val;
+                }
+            },
+            enumerable: true
+        },
+        croppedFull: {
+            get: function() {
+                return _croppedFull;
+            },
+            set: function(val) {
+                if (val !== _croppedFull) {
+                    setDisplayModeAbility(
+                        MediaControllerDisplayModeType.CROPPED_FULL,
+                        val
+                    );
+                    _croppedFull = val;
+                }
+            },
+            enumerable: true
+        }
+    });
+};
+
 var MediaControllerAbilitiesInfo = function(serverName) {
     Object.defineProperties(this, {
         playback: {
@@ -871,6 +949,11 @@ var MediaControllerAbilitiesInfo = function(serverName) {
             enumerable: true,
             writable: false
         },
+        displayMode: {
+            value: new MediaControllerDisplayModeAbilitiesInfo(serverName),
+            enumerable: true,
+            writable: false
+        },
         playbackPosition: {
             get: function() {
                 return getSimpleAbility(
@@ -1032,6 +1115,51 @@ var MediaControllerPlaybackAbilitiesInfo = function(serverName) {
     });
 };
 
+var MediaControllerDisplayModeAbilitiesInfo = function(serverName) {
+    Object.defineProperties(this, {
+        letterBox: {
+            get: function() {
+                return getDisplayModeAbility(
+                    serverName,
+                    MediaControllerDisplayModeType.LETTER_BOX
+                );
+            },
+            set: function() {},
+            enumerable: true
+        },
+        originSize: {
+            get: function() {
+                return getDisplayModeAbility(
+                    serverName,
+                    MediaControllerDisplayModeType.ORIGIN_SIZE
+                );
+            },
+            set: function() {},
+            enumerable: true
+        },
+        fullScreen: {
+            get: function() {
+                return getDisplayModeAbility(
+                    serverName,
+                    MediaControllerDisplayModeType.FULL_SCREEN
+                );
+            },
+            set: function() {},
+            enumerable: true
+        },
+        croppedFull: {
+            get: function() {
+                return getDisplayModeAbility(
+                    serverName,
+                    MediaControllerDisplayModeType.CROPPED_FULL
+                );
+            },
+            set: function() {},
+            enumerable: true
+        }
+    });
+};
+
 // subtitles
 var MediaControllerSubtitles = function() {
     // the default value is false
@@ -2445,6 +2573,33 @@ var checkSupportValue = function(support) {
     }
 };
 
+var setDisplayModeAbility = function(mode, val) {
+    checkSupportValue(val);
+
+    var data = {
+        mode: mode,
+        support: val
+    };
+    var result = native_.callSync('MediaControllerServer_setDisplayModeAbility', data);
+
+    if (native_.isFailure(result)) {
+        throw native_.getErrorObject(result);
+    }
+};
+
+var getDisplayModeAbility = function(serverName, mode) {
+    var data = {
+        serverName: serverName,
+        mode: mode
+    };
+
+    var result = native_.callSync('MediaControllerClient_getDisplayModeAbility', data);
+    if (native_.isFailure(result)) {
+        throw new native_.getErrorObject(result);
+    }
+    return native_.getResultObject(result);
+};
+
 function MediaControllerClient() {}
 
 MediaControllerClient.prototype.findServers = function(successCallback, errorCallback) {
@@ -2617,7 +2772,11 @@ MediaControllerClient.prototype.addAbilityChangeListener = function(callback) {
         {
             name: 'callback',
             type: types_.LISTENER,
-            values: ['onplaybackabilitychanged', 'onsimpleabilitychanged']
+            values: [
+                'onplaybackabilitychanged',
+                'ondisplaymodeabilitychanged',
+                'onsimpleabilitychanged'
+            ]
         }
     ]);
 

diff --git a/src/mediacontroller/mediacontroller_client.cc b/src/mediacontroller/mediacontroller_client.cc
index 2a42739..90564aa 100644 (file)
--- a/src/mediacontroller/mediacontroller_client.cc
+++ b/src/mediacontroller/mediacontroller_client.cc
@@ -224,6 +224,33 @@ PlatformResult MediaControllerClient::GetPlaybackAbility(const std::string& serv
   return PlatformResult(ErrorCode::NO_ERROR);
 }
 
+PlatformResult MediaControllerClient::GetDisplayModeAbility(const std::string& server_name,
+                                                            const std::string& mode,
+                                                            std::string* abilities) {
+  ScopeLogger();
+
+  mc_display_mode_e mode_e = MC_DISPLAY_MODE_LETTER_BOX;
+  PlatformResult result = types::MediaControllerDisplayModeEnum.getValue(mode, &mode_e);
+  if (!result) {
+    return LogAndCreateResult(
+        ErrorCode::UNKNOWN_ERR, "Error getting value of display mode",
+        ("MediaControllerDisplayModeEnum.getValue() failed, error: %s", result.message().c_str()));
+  }
+
+  u_int supported_items = 0;
+  int ret =
+      mc_client_get_server_display_mode_ability(handle_, server_name.c_str(), &supported_items);
+  if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Error getting display mode ability",
+                              ("mc_client_get_server_display_mode_ability() error: %d, message: %s",
+                               ret, get_error_message(ret)));
+  }
+
+  *abilities = (supported_items & mode_e) != 0 ? "YES" : "NO";
+
+  return PlatformResult(ErrorCode::NO_ERROR);
+}
+
 PlatformResult MediaControllerClient::GetSimpleAbility(const std::string& server_name,
                                                        const std::string& ability_type,
                                                        picojson::value* ability_val) {
@@ -535,9 +562,13 @@ PlatformResult MediaControllerClient::SetAbilityChangeListener(const JsonCallbac
   ScopeLogger();
   int failed_setters = 0;
   SCOPE_EXIT {
+    // Lambda function used to clean all set listeners.
+    // 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_ability_updated_cb,
+                                       mc_client_unset_display_mode_ability_updated_cb,
                                        mc_client_unset_ability_support_updated_cb};
 
+    // This loop is no-op in case of success.
     for (int i = 0; i < failed_setters; ++i) {
       auto ret = unsetters[i](handle_);
       if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
@@ -554,9 +585,18 @@ PlatformResult MediaControllerClient::SetAbilityChangeListener(const JsonCallbac
                                ret, get_error_message(ret)));
   }
 
-  ret = mc_client_set_ability_support_updated_cb(handle_, OnSimpleAbilityUpdate, this);
+  ret = mc_client_set_display_mode_ability_updated_cb(handle_, OnDisplayModeAbilityUpdate, this);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     failed_setters = 1;
+    return LogAndCreateResult(
+        ErrorCode::UNKNOWN_ERR, "Unable to register display mode ability listener",
+        ("mc_client_set_display_mode_ability_updated_cb() error: %d, message: %s", ret,
+         get_error_message(ret)));
+  }
+
+  ret = mc_client_set_ability_support_updated_cb(handle_, OnSimpleAbilityUpdate, this);
+  if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+    failed_setters = 2;
     return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Unable to register simple ability listener",
                               ("mc_client_set_ability_support_updated_cb() error: %d, message: %s",
                                ret, get_error_message(ret)));
@@ -593,6 +633,12 @@ PlatformResult MediaControllerClient::UnsetAbilityChangeListener() {
             get_error_message(ret));
   }
 
+  ret = mc_client_unset_display_mode_ability_updated_cb(handle_);
+  if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+    LoggerE("mc_client_unset_display_mode_ability_updated_cb() failed with error %d, message: %s",
+            ret, get_error_message(ret));
+  }
+
   ret = mc_client_unset_ability_support_updated_cb(handle_);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     LoggerW("mc_client_unset_ability_support_updated_cb() failed with error %d, message: %s", ret,
@@ -730,6 +776,21 @@ void MediaControllerClient::OnPlaybackAbilityUpdate(const char* server_name,
   client->ability_listener_(&data);
 }
 
+void MediaControllerClient::OnDisplayModeAbilityUpdate(const char* server_name, u_int mode,
+                                                       void* user_data) {
+  ScopeLogger();
+  MediaControllerClient* client = static_cast<MediaControllerClient*>(user_data);
+
+  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"));
+
+  client->ability_listener_(&data);
+}
+
 void MediaControllerClient::OnShuffleModeUpdate(const char* server_name, mc_shuffle_mode_e mode,
                                                 void* user_data) {
   ScopeLogger();

diff --git a/src/mediacontroller/mediacontroller_client.h b/src/mediacontroller/mediacontroller_client.h
index a7420de..3adacc0 100644 (file)
--- a/src/mediacontroller/mediacontroller_client.h
+++ b/src/mediacontroller/mediacontroller_client.h
@@ -65,6 +65,8 @@ class MediaControllerClient {
                                           common::optional<std::string>* icon_uri);
   common::PlatformResult GetPlaybackAbility(const std::string& server_name,
                                             const std::string& action, picojson::value* abilities);
+  common::PlatformResult GetDisplayModeAbility(const std::string& server_name,
+                                               const std::string& mode, std::string* abilities);
   common::PlatformResult SetAbilityChangeListener(const JsonCallback& callback);
   common::PlatformResult UnsetAbilityChangeListener();
   common::PlatformResult GetSimpleAbility(const std::string& server_name,
@@ -133,6 +135,7 @@ class MediaControllerClient {
                                const char* playlist_name, mc_playlist_h playlist, void* user_data);
   static void OnPlaybackAbilityUpdate(const char* server_name, mc_playback_ability_h ability,
                                       void* user_data);
+  static void OnDisplayModeAbilityUpdate(const char* server_name, u_int mode, void* user_data);
   static void OnSimpleAbilityUpdate(const char* server_name, mc_ability_e type,
                                     mc_ability_support_e mode, void* user_data);
   // subtitles

diff --git a/src/mediacontroller/mediacontroller_instance.cc b/src/mediacontroller/mediacontroller_instance.cc
index 1a9899d..88ac2f9 100644 (file)
--- a/src/mediacontroller/mediacontroller_instance.cc
+++ b/src/mediacontroller/mediacontroller_instance.cc
@@ -93,6 +93,8 @@ MediaControllerInstance::MediaControllerInstance() {
   REGISTER_SYNC("MediaControllerServer_updateIconURI", MediaControllerServerUpdateIconURI);
   REGISTER_SYNC("MediaControllerServer_savePlaybackAbilities",
                 MediaControllerServerSavePlaybackAbilities);
+  REGISTER_SYNC("MediaControllerServer_setDisplayModeAbility",
+                MediaControllerServerSetDisplayModeAbility);
   REGISTER_SYNC("MediaControllerServer_setSimpleAbility", MediaControllerServerSetSimpleAbility);
 
   // client
@@ -103,6 +105,8 @@ MediaControllerInstance::MediaControllerInstance() {
   REGISTER_SYNC("MediaControllerClient_getPlaybackInfo", MediaControllerClientGetPlaybackInfo);
   REGISTER_SYNC("MediaControllerClient_getPlaybackAbility",
                 MediaControllerClientGetPlaybackAbility);
+  REGISTER_SYNC("MediaControllerClient_getDisplayModeAbility",
+                MediaControllerClientGetDisplayModeAbility);
   REGISTER_SYNC("MediaControllerClient_getSimpleAbility", MediaControllerClientGetSimpleAbility);
   REGISTER_ASYNC("MediaControllerClient_findSubscribedServers",
                  MediaControllerClientFindSubscribedServers);
@@ -796,6 +800,31 @@ void MediaControllerInstance::MediaControllerServerSavePlaybackAbilities(
   ReportSuccess(out);
 }
 
+void MediaControllerInstance::MediaControllerServerSetDisplayModeAbility(
+    const picojson::value& args, picojson::object& out) {
+  ScopeLogger();
+
+  if (!server_) {
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
+                      ("Failed: server_"));
+    return;
+  }
+
+  CHECK_ARGS(args, "mode", std::string, out)
+  CHECK_ARGS(args, "support", std::string, out)
+
+  std::string support = args.get("support").get<std::string>();
+  std::string mode = args.get("mode").get<std::string>();
+
+  const PlatformResult& result = server_->SetDisplayModeAbility(mode, support);
+  if (!result) {
+    LogAndReportError(result, &out, ("Failed server_->SetDisplayModeAbility()"));
+    return;
+  }
+
+  ReportSuccess(out);
+}
+
 void MediaControllerInstance::MediaControllerServerSetSimpleAbility(const picojson::value& args,
                                                                     picojson::object& out) {
   ScopeLogger();
@@ -940,6 +969,31 @@ void MediaControllerInstance::MediaControllerClientGetPlaybackAbility(const pico
   ReportSuccess(ability, out);
 }
 
+void MediaControllerInstance::MediaControllerClientGetDisplayModeAbility(
+    const picojson::value& args, picojson::object& out) {
+  ScopeLogger();
+
+  if (!client_) {
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
+                      ("Failed: client_"));
+    return;
+  }
+
+  CHECK_ARGS(args, kServerName, std::string, out)
+  CHECK_ARGS(args, "mode", std::string, out)
+
+  std::string server_name = args.get(kServerName).get<std::string>();
+  std::string mode = args.get("mode").get<std::string>();
+  std::string ability;
+  PlatformResult result = client_->GetDisplayModeAbility(server_name, mode, &ability);
+  if (!result) {
+    LogAndReportError(result, &out, ("Failed: client_->GetDisplayModeAbility"));
+    return;
+  }
+
+  ReportSuccess(picojson::value(ability), out);
+}
+
 void MediaControllerInstance::MediaControllerClientGetSimpleAbility(const picojson::value& args,
                                                                     picojson::object& out) {
   ScopeLogger();

diff --git a/src/mediacontroller/mediacontroller_instance.h b/src/mediacontroller/mediacontroller_instance.h
index 0c9e3e8..edeb472 100644 (file)
--- a/src/mediacontroller/mediacontroller_instance.h
+++ b/src/mediacontroller/mediacontroller_instance.h
@@ -67,6 +67,8 @@ class MediaControllerInstance : public common::ParsedInstance {
   void MediaControllerServerUpdateIconURI(const picojson::value& args, picojson::object& out);
   void MediaControllerServerSavePlaybackAbilities(const picojson::value& args,
                                                   picojson::object& out);
+  void MediaControllerServerSetDisplayModeAbility(const picojson::value& args,
+                                                  picojson::object& out);
   void MediaControllerServerSetSimpleAbility(const picojson::value& args, picojson::object& out);
 
   // client
@@ -75,6 +77,8 @@ class MediaControllerInstance : public common::ParsedInstance {
   void MediaControllerClientGetLatestServerInfo(const picojson::value& args, picojson::object& out);
   void MediaControllerClientGetPlaybackInfo(const picojson::value& args, picojson::object& out);
   void MediaControllerClientGetPlaybackAbility(const picojson::value& args, picojson::object& out);
+  void MediaControllerClientGetDisplayModeAbility(const picojson::value& args,
+                                                  picojson::object& out);
   void MediaControllerClientGetSimpleAbility(const picojson::value& args, picojson::object& out);
   void MediaControllerClientAddAbilityChangeListener(const picojson::value& args,
                                                      picojson::object& out);

diff --git a/src/mediacontroller/mediacontroller_server.cc b/src/mediacontroller/mediacontroller_server.cc
index 353a509..c2223d7 100644 (file)
--- a/src/mediacontroller/mediacontroller_server.cc
+++ b/src/mediacontroller/mediacontroller_server.cc
@@ -758,6 +758,35 @@ PlatformResult MediaControllerServer::SavePlaybackAbilities(const picojson::valu
   return PlatformResult(ErrorCode::NO_ERROR);
 }
 
+PlatformResult MediaControllerServer::SetDisplayModeAbility(const std::string& mode,
+                                                            const std::string& support_str) {
+  ScopeLogger();
+
+  mc_display_mode_e mode_e;
+  PlatformResult result = types::MediaControllerDisplayModeEnum.getValue(mode, &mode_e);
+  if (!result) {
+    return LogAndCreateResult(
+        ErrorCode::UNKNOWN_ERR, "Error getting value of display mode",
+        ("MediaControllerDisplayModeEnum.getValue() failed, error: %s", result.message().c_str()));
+  }
+
+  mc_ability_support_e support_e;
+  result = types::MediaControllerAbilitySupportEnum.getValue(support_str, &support_e);
+  if (!result) {
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Error getting value of ability support",
+                              ("MediaControllerAbilitySupportEnum.getValue() failed, error: %s",
+                               result.message().c_str()));
+  }
+
+  int ret = mc_server_set_display_mode_ability(handle_, mode_e, support_e);
+  if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Error setting playback ability",
+                              ("mc_server_set_display_mode_ability() error: %d, message: %s", ret,
+                               get_error_message(ret)));
+  }
+  return PlatformResult(ErrorCode::NO_ERROR);
+}
+
 PlatformResult MediaControllerServer::SetSimpleAbility(const std::string& ability_type,
                                                        const std::string& support_str) {
   ScopeLogger();

diff --git a/src/mediacontroller/mediacontroller_server.h b/src/mediacontroller/mediacontroller_server.h
index 3c84c12..b85ac27 100644 (file)
--- a/src/mediacontroller/mediacontroller_server.h
+++ b/src/mediacontroller/mediacontroller_server.h
@@ -67,6 +67,8 @@ class MediaControllerServer {
   common::PlatformResult SetPlaybackAbility(const std::string& action,
                                             const std::string& support_str, bool* is_changed);
   common::PlatformResult SavePlaybackAbilities(const picojson::value& abilities);
+  common::PlatformResult SetDisplayModeAbility(const std::string& mode,
+                                               const std::string& support_str);
   common::PlatformResult SetSimpleAbility(const std::string& ability_type,
                                           const std::string& support_str);
   // subtitles