[TV][Audio] Remove try/catch to adjust to google coding style

[Verification] Code compiles without error.

Change-Id: I3f8839c918a55e606c36613615968172229e4d36
Signed-off-by: Piotr Czaja <p.czaja@samsung.com>

diff --git a/src/tvaudio/tvaudio_instance.cc b/src/tvaudio/tvaudio_instance.cc
index 55e9a1c1df3a704874628409e830fb227d3b2f02..17cdaf4df27565c20d0ad8d2eb8d40f0b8440e1c 100644 (file)
--- a/src/tvaudio/tvaudio_instance.cc
+++ b/src/tvaudio/tvaudio_instance.cc
@@ -52,57 +52,113 @@ void TVAudioInstance::setMute(const picojson::value& args,
         picojson::object& out) {
     LOGD("Enter");
     bool mute = args.get("mute").get<bool>();
-    AudioControlManager::getInstance().setMute(mute);
-    ReportSuccess(out);
+    common::PlatformResult result =
+            AudioControlManager::getInstance().setMute(mute);
+    if (result.IsError()) {
+        LOGD("Error occured");
+        ReportError(result, &out);
+    } else {
+        picojson::value result;
+        ReportSuccess(result, out);
+    }
 }
 
 void TVAudioInstance::isMute(const picojson::value& args,
         picojson::object& out) {
     LOGD("Enter");
-    bool mute = AudioControlManager::getInstance().isMute();
-    ReportSuccess(picojson::value(mute), out);
+    bool mute;
+    common::PlatformResult result =
+            AudioControlManager::getInstance().isMute(mute);
+    if (result.IsError()) {
+        LOGD("Error occured");
+        ReportError(result, &out);
+    } else
+        ReportSuccess(picojson::value(mute), out);
 }
 
 void TVAudioInstance::setVolume(const picojson::value& args,
         picojson::object& out) {
     LOGD("Enter");
     double volume = args.get("volume").get<double>();
-    AudioControlManager::getInstance().setVolume(volume);
-    ReportSuccess(out);
+    common::PlatformResult result =
+            AudioControlManager::getInstance().setVolume(volume);
+    if (result.IsError()) {
+        LOGD("Error occured");
+        ReportError(result, &out);
+    } else {
+        picojson::value result;
+        ReportSuccess(result, out);
+    }
 }
 
 void TVAudioInstance::setVolumeUp(const picojson::value& args,
         picojson::object& out) {
     LOGD("Enter");
-    AudioControlManager::getInstance().setVolumeUp();
-    ReportSuccess(out);
+    common::PlatformResult result =
+            AudioControlManager::getInstance().setVolumeUp();
+    if (result.IsError()) {
+        LOGD("Error occured");
+        ReportError(result, &out);
+    } else {
+        picojson::value result;
+        ReportSuccess(result, out);
+    }
 }
 
 void TVAudioInstance::setVolumeDown(const picojson::value& args,
         picojson::object& out) {
     LOGD("Enter");
-    AudioControlManager::getInstance().setVolumeDown();
-    ReportSuccess(out);
+    common::PlatformResult result =
+            AudioControlManager::getInstance().setVolumeDown();
+    if (result.IsError()) {
+        LOGD("Error occured");
+        ReportError(result, &out);
+    } else {
+        picojson::value result;
+        ReportSuccess(result, out);
+    }
 }
 
 void TVAudioInstance::getVolume(const picojson::value& args,
         picojson::object& out) {
     LOGD("Enter");
-    u_int16_t volume = AudioControlManager::getInstance().getVolume();
-    ReportSuccess(picojson::value(static_cast<double>(volume)), out);
+    u_int16_t volume;
+    common::PlatformResult result =
+            AudioControlManager::getInstance().getVolume(volume);
+    if (result.IsError()) {
+        LOGD("Error occured");
+        ReportError(result, &out);
+    } else {
+        picojson::value result = picojson::value(static_cast<double>(volume));
+        ReportSuccess(result, out);
+    }
 }
 
 void TVAudioInstance::getOutputMode(const picojson::value& args,
         picojson::object& out) {
     LOGD("Enter");
-    AudioOutputMode mode = AudioControlManager::getInstance().getOutputMode();
+    AudioOutputMode mode;
+    common::PlatformResult result =
+            AudioControlManager::getInstance().getOutputMode(mode);
+    if (result.IsError()) {
+        LOGD("Error occured");
+        ReportError(result, &out);
+    } else {
     ReportSuccess(picojson::value(AudioOutputModeMap.at(mode)), out);
+    }
 }
 
 void TVAudioInstance::setVolumeChangeListener(const picojson::value& args,
         picojson::object& out) {
-    AudioControlManager::getInstance().registerVolumeChangeListener(this);
-    ReportSuccess(out);
+    common::PlatformResult result =
+            AudioControlManager::getInstance().registerVolumeChangeListener(this);
+    if (result.IsError()) {
+        LOGD("Error occured");
+        ReportError(result, &out);
+    } else {
+        picojson::value result;
+        ReportSuccess(result, out);
+    }
 }
 
 void TVAudioInstance::unsetVolumeChangeListener(const picojson::value& args,
@@ -113,24 +169,25 @@ void TVAudioInstance::unsetVolumeChangeListener(const picojson::value& args,
 
 void TVAudioInstance::onVolumeChangeCallback(u_int16_t volume) {
   LOGD("Enter");
-  try {
-      picojson::value event = picojson::value(picojson::object());
-      picojson::object& obj = event.get<picojson::object>();
-      obj["listenerId"] = picojson::value("VolumeChangeCallback");
-      obj["volume"] = picojson::value(static_cast<double>(volume));
-      PostMessage(event.serialize().c_str());
-  } catch (common::PlatformException& e) {
-    LOGW("Failed to post message: %s", e.message().c_str());
-  } catch (...) {
-    LOGW("Failed to post message, unknown error");
-  }
+    picojson::value event = picojson::value(picojson::object());
+    picojson::object& obj = event.get<picojson::object>();
+    obj["listenerId"] = picojson::value("VolumeChangeCallback");
+    obj["volume"] = picojson::value(static_cast<double>(volume));
+    PostMessage(event.serialize().c_str());
 }
 
 void TVAudioInstance::playSound(const picojson::value& args,
         picojson::object& out) {
     const std::string& type = args.get("type").to_str();
-    AudioControlManager::getInstance().playSound(type);
-    ReportSuccess(picojson::value(true), out);
+    common::PlatformResult result =
+            AudioControlManager::getInstance().playSound(type);
+    if (result.IsError()) {
+        LOGD("Error occured");
+        ReportError(result, &out);
+    } else {
+        picojson::value result;
+        ReportSuccess(result, out);
+    }
 }
 
 }  // namespace tvaudio

diff --git a/src/tvaudio/tvaudio_manager.cc b/src/tvaudio/tvaudio_manager.cc
index bec083aad9037614a2f9408d788f9195189072a3..d0843e949d14b1041316b504f005f3758ae825c1 100755 (executable)
--- a/src/tvaudio/tvaudio_manager.cc
+++ b/src/tvaudio/tvaudio_manager.cc
@@ -25,6 +25,7 @@ namespace tvaudio {
 
 using common::UnknownException;
 using common::InvalidValuesException;
+using common::ErrorCode;
 
 namespace {
 const int AVOC_SUCCESS = 0;
@@ -52,101 +53,137 @@ AudioControlManager& AudioControlManager::getInstance() {
   return instance;
 }
 
-void AudioControlManager::setMute(bool mute) {
-    LOGD("Enter. Mute: %d", mute);
+common::PlatformResult AudioControlManager::setMute(bool mute) {
+    LOGD("Enter");
     int ret = sound_manager_set_master_mute(mute);
     if (SOUND_MANAGER_ERROR_NONE != ret) {
         LOGE("Failed to change mute state: %d", ret);
-        throw UnknownException("Failed to change mute state");
+        return common::PlatformResult(ErrorCode::UNKNOWN_ERR,
+            "Unknown error. Failed to change mute state");
     }
+    return common::PlatformResult(ErrorCode::NO_ERROR);
 }
 
-bool AudioControlManager::isMute() {
+common::PlatformResult AudioControlManager::isMute(bool &isMute) {
     LOGD("Enter");
-    bool muteState;
-    int ret = sound_manager_get_master_mute(&muteState);
+    int ret = sound_manager_get_master_mute(&isMute);
     if (SOUND_MANAGER_ERROR_NONE != ret) {
         LOGE("Failed to get mute state: %d", ret);
-        throw UnknownException("Failed to get mute state");
+        return common::PlatformResult(ErrorCode::UNKNOWN_ERR,
+            "Unknown error. Failed to get mute state");
     }
-    LOGD("Mute state: %d", muteState);
-    return muteState;
+    LOGD("Mute state: %d", isMute);
+    return common::PlatformResult(ErrorCode::NO_ERROR);
 }
 
-void AudioControlManager::setVolume(u_int16_t volume) {
+common::PlatformResult AudioControlManager::setVolume(u_int16_t volume) {
     LOGD("Enter. Volume: %d", volume);
     if (volume > 100) {
         LOGE("Invalid volume number");
-        throw InvalidValuesException("Invalid volume number");
+        return common::PlatformResult(ErrorCode::INVALID_VALUES_ERR,
+            "Invalid volume number");
     }
     int ret = sound_manager_set_master_volume(volume);
     if (SOUND_MANAGER_ERROR_NONE != ret) {
         LOGE("Failed to set volume: %d", ret);
-        throw UnknownException("Failed to set volume");
+        return common::PlatformResult(ErrorCode::UNKNOWN_ERR,
+            "Unknown error. Failed to set volume");
     }
+    return common::PlatformResult(ErrorCode::NO_ERROR);
 }
 
-void AudioControlManager::setVolumeUp() {
+common::PlatformResult AudioControlManager::setVolumeUp() {
     LOGD("Enter");
-    u_int16_t currentVolume = getVolume();
+    common::PlatformResult ret(ErrorCode::NO_ERROR);
+    u_int16_t currentVolume;
+    ret = getVolume(currentVolume);
+    if (ret.IsError())
+        return ret;
     if (currentVolume < 100) {
-        setVolume(currentVolume + m_volume_step <= 100 ?
+        ret = setVolume(currentVolume + m_volume_step <= 100 ?
                 currentVolume + m_volume_step : 100);
+        if (ret.IsError())
+            return ret;
     }
-    if (isMute()) {
-        setMute(false);
+    bool muteState;
+    ret = isMute(muteState);
+    if (ret.IsError())
+        return ret;
+    if (muteState) {
+        return setMute(false);
     }
+    return common::PlatformResult(ErrorCode::NO_ERROR);
 }
 
-void AudioControlManager::setVolumeDown() {
+common::PlatformResult AudioControlManager::setVolumeDown() {
     LOGD("Enter");
-    u_int16_t currentVolume = getVolume();
+    common::PlatformResult ret(ErrorCode::NO_ERROR);
+    u_int16_t currentVolume;
+    ret = getVolume(currentVolume);
+    if (ret.IsError())
+        return ret;
     if (currentVolume > 0) {
-        setVolume(currentVolume >= m_volume_step ?
+        ret = setVolume(currentVolume >= m_volume_step ?
                 currentVolume - m_volume_step : 0);
+        if (ret.IsError())
+            return ret;
     }
-    if (isMute()) {
-        setMute(false);
+    bool muteState;
+    ret = isMute(muteState);
+    if (ret.IsError())
+        return ret;
+    if (muteState) {
+        return setMute(false);
     }
+    return common::PlatformResult(ErrorCode::NO_ERROR);
 }
 
-u_int16_t AudioControlManager::getVolume() {
+common::PlatformResult AudioControlManager::getVolume(u_int16_t &volume) {
     LOGD("Enter");
-    int volume;
-    int ret = sound_manager_get_master_volume(&volume);
+    int tempVolume;
+    int ret = sound_manager_get_master_volume(&tempVolume);
     if (SOUND_MANAGER_ERROR_NONE != ret) {
         LOGE("Failed to get volume: %d", ret);
-        throw UnknownException("Failed to get volume");
+        return common::PlatformResult(ErrorCode::UNKNOWN_ERR,
+            "Unknown error. Failed to get volume");
     }
     LOGD("Volume: %d", volume);
-    return volume;
+    volume = tempVolume;
+    return common::PlatformResult(ErrorCode::NO_ERROR);
 }
 
-AudioOutputMode AudioControlManager::getOutputMode() {
+common::PlatformResult AudioControlManager::getOutputMode(AudioOutputMode mode) {
     LOGD("Enter");
     avoc_audio_format_e type;
     int ret = avoc_get_audio_format(&type);
     if (AVOC_SUCCESS != ret) {
         LOGE("Failed to get audio output type: %d", ret);
-        throw UnknownException("Failed to get audio output type");
+        return common::PlatformResult(ErrorCode::UNKNOWN_ERR,
+            "Unknown error. Failed to get audio output type");
     }
     switch (type) {
         case AVOC_AUDIO_FORMAT_PCM:
-            return AudioOutputMode::PCM;
+            mode = AudioOutputMode::PCM;
+            break;
         case AVOC_AUDIO_FORMAT_ES_DOLBY_DIGITAL:
-            return AudioOutputMode::DOLBY;
+            mode = AudioOutputMode::DOLBY;
+            break;
         case AVOC_AUDIO_FORMAT_ES_DTS:
         case AVOC_AUDIO_FORMAT_NEO_ES_DTS:
-            return AudioOutputMode::DTS;
+            mode = AudioOutputMode::DTS;
+            break;
         case AVOC_AUDIO_FORMAT_ES_AAC:
-            return AudioOutputMode::AAC;
+            mode = AudioOutputMode::AAC;
+            break;
         default:
             LOGE("Unexpected audio output type: %d", type);
-            throw UnknownException("Unexecpted audio output type");
+            return common::PlatformResult(ErrorCode::UNKNOWN_ERR,
+                "Unexecpted audio output type");
     }
+    return common::PlatformResult(ErrorCode::NO_ERROR);
 }
 
-void AudioControlManager::registerVolumeChangeListener(
+common::PlatformResult AudioControlManager::registerVolumeChangeListener(
             VolumeChangeListener* listener) {
     LOGD("Enter");
     unregisterVolumeChangeListener();
@@ -154,19 +191,24 @@ void AudioControlManager::registerVolumeChangeListener(
             volumeChangeCallback, NULL);
     if (SOUND_MANAGER_ERROR_NONE != r) {
         LOGE("Failed to add listener: %d", r);
-        throw UnknownException("Failed to add listener");
+        return common::PlatformResult(ErrorCode::UNKNOWN_ERR,
+            "Failed to add listener");
     }
     m_volume_change_listener = listener;
     LOGD("Added listener");
+    return common::PlatformResult(ErrorCode::NO_ERROR);
 }
 
-void AudioControlManager::unregisterVolumeChangeListener() {
+common::PlatformResult AudioControlManager::unregisterVolumeChangeListener() {
     LOGD("Enter");
     int r = sound_manager_unset_master_volume_changed_cb();
     if (SOUND_MANAGER_ERROR_NONE != r) {
         LOGW("Failed to remove listener: %d", r);
+        return common::PlatformResult(ErrorCode::UNKNOWN_ERR,
+            "Failed to remove listener");
     }
     m_volume_change_listener = NULL;
+    return common::PlatformResult(ErrorCode::NO_ERROR);
 }
 
 void AudioControlManager::volumeChangeCallback(
@@ -180,21 +222,16 @@ void AudioControlManager::volumeChangeCallback(
 
 gboolean AudioControlManager::onVolumeChange(gpointer /*user_data*/) {
     LOGD("Enter");
-    try {
-        if (!getInstance().m_volume_change_listener) {
-            LOGD("Listener is null. Ignoring");
-            return G_SOURCE_REMOVE;
-        }
-        u_int16_t val;
-        try {
-            val = getInstance().getVolume();
-        } catch (...) {
-            LOGE("Failed to retrieve volume level");
-        }
-        getInstance().m_volume_change_listener->onVolumeChangeCallback(val);
-    } catch (...) {
-        LOGE("Failed to call callback");
+    if (!getInstance().m_volume_change_listener) {
+        LOGD("Listener is null. Ignoring");
+        return G_SOURCE_REMOVE;
+    }
+    u_int16_t val;
+    common::PlatformResult ret = getInstance().getVolume(val);
+    if (ret.IsError()) {
+        LOGE("Failed to retrieve volume level");
     }
+    getInstance().m_volume_change_listener->onVolumeChangeCallback(val);
     return G_SOURCE_REMOVE;
 }
 
@@ -202,14 +239,13 @@ gboolean AudioControlManager::onVolumeChange(gpointer /*user_data*/) {
  * Play one of predefined sounds
  *
  * If sound is already played it is replaced by the new sound
- *
- * @return {bool} true if successful, false otherwise
  */
-bool AudioControlManager::playSound(const std::string &type) {
+common::PlatformResult AudioControlManager::playSound(const std::string &type) {
     LOGD("Enter");
     const auto beep = SoundMap.find(type);
     if (beep == SoundMap.end()) {
-        throw UnknownException("Unknown beep type: " + type);
+        return common::PlatformResult(ErrorCode::UNKNOWN_ERR,
+            "Unknown error. Unknown beep type: " + type);
     }
 
     void *status;
@@ -229,9 +265,10 @@ bool AudioControlManager::playSound(const std::string &type) {
         m_playThreadIdInit = true;
     } else {
         LOGE("Failed to create pthread");
-        throw UnknownException("Failed to create pthread to play sound");
+        return common::PlatformResult(ErrorCode::UNKNOWN_ERR,
+            "Failed to create pthread to play sound");
     }
-    return true;
+    return common::PlatformResult(ErrorCode::NO_ERROR);
 }
 
 void* AudioControlManager::play(void* play_data) {

diff --git a/src/tvaudio/tvaudio_manager.h b/src/tvaudio/tvaudio_manager.h
index 2ba27c9d107c3efe36e4494277cf5c0735b91198..4de64a883d3f713fd92710b347dba7e19545157c 100755 (executable)
--- a/src/tvaudio/tvaudio_manager.h
+++ b/src/tvaudio/tvaudio_manager.h
@@ -14,6 +14,7 @@
 
 
 #include <sys/types.h>
+#include "common/platform_result.h"
 
 namespace extension {
 namespace tvaudio {
@@ -33,16 +34,16 @@ class VolumeChangeListener {
 
 class AudioControlManager {
  public:
-    void setMute(bool mute);
-    bool isMute();
-    void setVolume(u_int16_t volume);
-    void setVolumeUp();
-    void setVolumeDown();
-    bool playSound(const std::string &type);
-    u_int16_t getVolume();
-    AudioOutputMode getOutputMode();
-    void registerVolumeChangeListener(VolumeChangeListener* listener);
-    void unregisterVolumeChangeListener();
+    common::PlatformResult setMute(bool mute);
+    common::PlatformResult isMute(bool &isMute);
+    common::PlatformResult setVolume(u_int16_t volume);
+    common::PlatformResult setVolumeUp();
+    common::PlatformResult setVolumeDown();
+    common::PlatformResult playSound(const std::string &type);
+    common::PlatformResult getVolume(u_int16_t &volume);
+    common::PlatformResult getOutputMode(AudioOutputMode mode);
+    common::PlatformResult registerVolumeChangeListener(VolumeChangeListener* listener);
+    common::PlatformResult unregisterVolumeChangeListener();
     static void volumeChangeCallback(unsigned int volume, void* user_data);
     static gboolean onVolumeChange(gpointer user_data);