diff --git a/packages/flutter_tts/CHANGELOG.md b/packages/flutter_tts/CHANGELOG.md
index 4e2fef778..a89a57295 100644
--- a/packages/flutter_tts/CHANGELOG.md
+++ b/packages/flutter_tts/CHANGELOG.md
@@ -1,3 +1,7 @@
+## 1.2.1
+
+* Refactor the C++ code.
+
 ## 1.2.0
 
 * Fix a bug where `setLanguage()` wasn't invoked due to typo in `setLanguage`.
diff --git a/packages/flutter_tts/pubspec.yaml b/packages/flutter_tts/pubspec.yaml
index 58461e2d9..5b443d38e 100644
--- a/packages/flutter_tts/pubspec.yaml
+++ b/packages/flutter_tts/pubspec.yaml
@@ -2,7 +2,7 @@ name: flutter_tts_tizen
 description: The tizen implementation of flutter_tts plugin.
 homepage: https://github.com/flutter-tizen/plugins
 repository: https://github.com/flutter-tizen/plugins/tree/master/packages/flutter_tts
-version: 1.2.0
+version: 1.2.1
 
 dependencies:
   flutter:
diff --git a/packages/flutter_tts/tizen/src/flutter_tts_tizen_plugin.cc b/packages/flutter_tts/tizen/src/flutter_tts_tizen_plugin.cc
index 565f1ad88..36d2c6463 100644
--- a/packages/flutter_tts/tizen/src/flutter_tts_tizen_plugin.cc
+++ b/packages/flutter_tts/tizen/src/flutter_tts_tizen_plugin.cc
@@ -8,15 +8,19 @@
 #include <flutter/plugin_registrar.h>
 #include <flutter/standard_method_codec.h>
 
-#include <map>
 #include <memory>
-#include <sstream>
+#include <optional>
 #include <string>
 #include <vector>
 
 #include "log.h"
 #include "text_to_speech.h"
 
+namespace {
+
+typedef flutter::MethodChannel<flutter::EncodableValue> FlMethodChannel;
+typedef flutter::MethodResult<flutter::EncodableValue> FlMethodResult;
+
 class FlutterTtsTizenPlugin : public flutter::Plugin {
  public:
   static void RegisterWithRegistrar(flutter::PluginRegistrar *registrar) {
@@ -25,16 +29,23 @@ class FlutterTtsTizenPlugin : public flutter::Plugin {
   }
 
   FlutterTtsTizenPlugin(flutter::PluginRegistrar *registrar) {
-    channel_ =
-        std::make_unique<flutter::MethodChannel<flutter::EncodableValue>>(
-            registrar->messenger(), "flutter_tts",
-            &flutter::StandardMethodCodec::GetInstance());
+    channel_ = std::make_unique<FlMethodChannel>(
+        registrar->messenger(), "flutter_tts",
+        &flutter::StandardMethodCodec::GetInstance());
     channel_->SetMethodCallHandler([this](const auto &call, auto result) {
       this->HandleMethodCall(call, std::move(result));
     });
 
     tts_ = std::make_unique<TextToSpeech>();
-    tts_->SetOnStateChanagedCallback(
+    if (!tts_->Initialize()) {
+      // TODO : Handle initialization failure cases
+      // Rarely, initializing TextToSpeech can fail. we should consider catching
+      // the exception and propagating it to the flutter side. however, I think
+      // this is optional because flutter side is not expecting any errors.
+      tts_ = nullptr;
+      return;
+    }
+    tts_->SetStateChanagedCallback(
         [this](tts_state_e previous, tts_state_e current) -> void {
           std::unique_ptr<flutter::EncodableValue> value =
               std::make_unique<flutter::EncodableValue>(true);
@@ -57,15 +68,14 @@ class FlutterTtsTizenPlugin : public flutter::Plugin {
           }
         });
 
-    tts_->SetOnUtteranceCompletedCallback([this](int utt_id) -> void {
-      LOG_INFO("[TTS] Utterance (%d) is completed", utt_id);
+    tts_->SetUtteranceCompletedCallback([this](int32_t utt_id) -> void {
       std::unique_ptr<flutter::EncodableValue> args =
           std::make_unique<flutter::EncodableValue>(true);
       channel_->InvokeMethod("speak.onComplete", std::move(args));
       HandleAwaitSpeakCompletion(1);
     });
 
-    tts_->SetErrorCallback([](int utt_id, tts_error_e reason) -> void {
+    tts_->SetErrorCallback([](int32_t utt_id, tts_error_e reason) -> void {
       // It seems unnecessary for now.
     });
   }
@@ -82,107 +92,159 @@ class FlutterTtsTizenPlugin : public flutter::Plugin {
     // notify the dart code of any method call failures from the host platform.
     // However, in the case of flutter_tts, it expects a return value 0 on
     // failure(and value 1 on success). Therefore in the scope of this plugin,
-    // we call result->Success(flutter::EncodableValue(0)) to notify errors.
-
+    // we call SendResult(flutter::EncodableValue(0)); to notify errors.
     const auto method_name = method_call.method_name();
     const auto &arguments = *method_call.arguments();
 
-    if (method_name.compare("awaitSpeakCompletion") == 0) {
-      if (std::holds_alternative<bool>(arguments)) {
-        await_speak_completion_ = std::get<bool>(arguments);
-        result->Success(flutter::EncodableValue(1));
-        return;
-      }
-      result->Success(flutter::EncodableValue(0));
-    } else if (method_name.compare("speak") == 0) {
-      if (tts_->GetState() == TTS_STATE_PLAYING) {
-        LOG_ERROR("[TTS] : You cannot speak again while speaking.");
-        result->Success(flutter::EncodableValue(0));
-        return;
-      }
+    result_ = std::move(result);
 
-      if (std::holds_alternative<std::string>(arguments)) {
-        std::string text = std::get<std::string>(arguments);
-        if (!tts_->AddText(text)) {
-          result->Success(flutter::EncodableValue(0));
-          return;
-        }
-      }
+    if (!tts_) {
+      result_->Error("Operation failed", "TTS is invalid.");
+      return;
+    }
 
-      if (tts_->Speak()) {
-        if (await_speak_completion_ && !result_for_await_speak_completion_) {
-          LOG_DEBUG("Store result ptr for await speak completion");
-          result_for_await_speak_completion_ = std::move(result);
-        } else {
-          result->Success(flutter::EncodableValue(1));
-        }
-      } else {
-        result->Success(flutter::EncodableValue(0));
+    if (method_name == "awaitSpeakCompletion") {
+      OnAwaitSpeakCompletion(arguments);
+    } else if (method_name == "speak") {
+      OnSpeak(arguments);
+    } else if (method_name == "stop") {
+      OnStop();
+    } else if (method_name == "pause") {
+      OnPause();
+    } else if (method_name == "getSpeechRateValidRange") {
+      OnGetSpeechRateValidRange();
+    } else if (method_name == "setSpeechRate") {
+      OnSetSpeechRate(arguments);
+    } else if (method_name == "setLanguage") {
+      OnSetLanguage(arguments);
+    } else if (method_name == "getLanguages") {
+      OnGetLanguage();
+    } else if (method_name == "setVolume") {
+      OnSetVolume(arguments);
+    } else {
+      result_->NotImplemented();
+    }
+  }
+
+  void OnAwaitSpeakCompletion(const flutter::EncodableValue &arguments) {
+    if (std::holds_alternative<bool>(arguments)) {
+      await_speak_completion_ = std::get<bool>(arguments);
+      SendResult(flutter::EncodableValue(1));
+      return;
+    }
+    SendResult(flutter::EncodableValue(0));
+  }
+
+  void OnSpeak(const flutter::EncodableValue &arguments) {
+    std::optional<TtsState> state = tts_->GetState();
+    if (!state.has_value() || state == TtsState::kPlaying) {
+      if (state.has_value() && state == TtsState::kPlaying) {
+        LOG_ERROR("You cannot speak again while speaking.");
       }
-    } else if (method_name.compare("stop") == 0) {
-      if (tts_->Stop()) {
-        result->Success(flutter::EncodableValue(1));
-      } else {
-        result->Success(flutter::EncodableValue(0));
+      SendResult(flutter::EncodableValue(0));
+      return;
+    }
+
+    if (std::holds_alternative<std::string>(arguments)) {
+      std::string text = std::get<std::string>(arguments);
+      if (!tts_->AddText(text)) {
+        SendResult(flutter::EncodableValue(0));
+        return;
       }
-    } else if (method_name.compare("pause") == 0) {
-      if (tts_->Pause()) {
-        result->Success(flutter::EncodableValue(1));
+    }
+
+    if (tts_->Speak()) {
+      if (await_speak_completion_ && !result_for_await_speak_completion_) {
+        result_for_await_speak_completion_ = std::move(result_);
       } else {
-        result->Success(flutter::EncodableValue(0));
-      }
-    } else if (method_name.compare("getSpeechRateValidRange") == 0) {
-      int min = 0, normal = 0, max = 0;
-      tts_->GetSpeedRange(&min, &normal, &max);
-      flutter::EncodableMap map;
-      map.insert(std::pair<flutter::EncodableValue, flutter::EncodableValue>(
-          "min", min));
-      map.insert(std::pair<flutter::EncodableValue, flutter::EncodableValue>(
-          "normal", normal));
-      map.insert(std::pair<flutter::EncodableValue, flutter::EncodableValue>(
-          "max", max));
-      map.insert(std::pair<flutter::EncodableValue, flutter::EncodableValue>(
-          "platform", "tizen"));
-      result->Success(flutter::EncodableValue(std::move(map)));
-    } else if (method_name.compare("setSpeechRate") == 0) {
-      if (std::holds_alternative<double>(arguments)) {
-        int speed = (int)std::get<double>(arguments);
-        tts_->SetTtsSpeed(speed);
-        result->Success(flutter::EncodableValue(1));
-        return;
+        SendResult(flutter::EncodableValue(1));
       }
-      result->Success(flutter::EncodableValue(0));
-    } else if (method_name.compare("setLanguage") == 0) {
-      if (std::holds_alternative<std::string>(arguments)) {
-        std::string language = std::move(std::get<std::string>(arguments));
-        tts_->SetDefaultLanguage(language);
-        result->Success(flutter::EncodableValue(1));
+    } else {
+      SendResult(flutter::EncodableValue(0));
+    }
+  }
+
+  void OnStop() {
+    if (tts_->Stop()) {
+      SendResult(flutter::EncodableValue(1));
+    } else {
+      SendResult(flutter::EncodableValue(0));
+    }
+  }
+
+  void OnPause() {
+    if (tts_->Pause()) {
+      SendResult(flutter::EncodableValue(1));
+    } else {
+      SendResult(flutter::EncodableValue(0));
+    }
+  }
+
+  void OnGetSpeechRateValidRange() {
+    int32_t min = 0, normal = 0, max = 0;
+    tts_->GetSpeedRange(&min, &normal, &max);
+    // FIXME: The value of "platform" is temporarily set to "android" instead of
+    // "tizen". Because it is not declared in TextToSpeechPlatform of
+    // TextToSpeech example.
+    flutter::EncodableMap map = {
+        {flutter::EncodableValue("min"), flutter::EncodableValue(min)},
+        {flutter::EncodableValue("normal"), flutter::EncodableValue(normal)},
+        {flutter::EncodableValue("max"), flutter::EncodableValue(max)},
+        {flutter::EncodableValue("platform"),
+         flutter::EncodableValue("android")},
+    };
+    SendResult(flutter::EncodableValue(map));
+  }
+
+  void OnSetSpeechRate(const flutter::EncodableValue &arguments) {
+    if (std::holds_alternative<double>(arguments)) {
+      int32_t speed = std::get<double>(arguments);
+      tts_->SetTtsSpeed(speed);
+      SendResult(flutter::EncodableValue(1));
+      return;
+    }
+    SendResult(flutter::EncodableValue(0));
+  }
+
+  void OnSetLanguage(const flutter::EncodableValue &arguments) {
+    if (std::holds_alternative<std::string>(arguments)) {
+      std::string language = std::move(std::get<std::string>(arguments));
+      tts_->SetDefaultLanguage(language);
+      SendResult(flutter::EncodableValue(1));
+      return;
+    }
+    SendResult(flutter::EncodableValue(0));
+  }
+
+  void OnGetLanguage() {
+    flutter::EncodableList list;
+    for (auto language : tts_->GetSupportedLanaguages()) {
+      list.push_back(flutter::EncodableValue(language));
+    }
+    SendResult(flutter::EncodableValue(list));
+  }
+
+  void OnSetVolume(const flutter::EncodableValue &arguments) {
+    if (std::holds_alternative<double>(arguments)) {
+      double volume = std::get<double>(arguments);
+      if (tts_->SetVolume(volume)) {
+        SendResult(flutter::EncodableValue(1));
         return;
       }
-      result->Success(flutter::EncodableValue(0));
-    } else if (method_name.compare("getLanguages") == 0) {
-      flutter::EncodableList list;
-      for (auto language : tts_->GetSupportedLanaguages()) {
-        list.push_back(flutter::EncodableValue(language));
-      }
-      result->Success(flutter::EncodableValue(list));
-    } else if (method_name.compare("setVolume") == 0) {
-      if (std::holds_alternative<double>(arguments)) {
-        double rate = std::get<double>(arguments);
-        if (tts_->SetVolume(rate)) {
-          result->Success(flutter::EncodableValue(1));
-          return;
-        }
-      }
-      result->Success(flutter::EncodableValue(0));
-    } else {
-      result->Error("-1", "Not supported method");
     }
+    SendResult(flutter::EncodableValue(0));
+  }
+
+  void SendResult(const flutter::EncodableValue &result) {
+    if (!result_) {
+      return;
+    }
+    result_->Success(result);
+    result_ = nullptr;
   }
 
-  void HandleAwaitSpeakCompletion(int value) {
+  void HandleAwaitSpeakCompletion(int32_t value) {
     if (await_speak_completion_) {
-      LOG_DEBUG("Send result for await speak completion[%d]", value);
       result_for_await_speak_completion_->Success(
           flutter::EncodableValue(value));
       result_for_await_speak_completion_ = nullptr;
@@ -190,13 +252,15 @@ class FlutterTtsTizenPlugin : public flutter::Plugin {
   }
 
   std::unique_ptr<TextToSpeech> tts_;
-  std::unique_ptr<flutter::MethodChannel<flutter::EncodableValue>> channel_;
-
   bool await_speak_completion_ = false;
-  std::unique_ptr<flutter::MethodResult<flutter::EncodableValue>>
-      result_for_await_speak_completion_;
+
+  std::unique_ptr<FlMethodResult> result_for_await_speak_completion_;
+  std::unique_ptr<FlMethodResult> result_;
+  std::unique_ptr<FlMethodChannel> channel_;
 };
 
+}  // namespace
+
 void FlutterTtsTizenPluginRegisterWithRegistrar(
     FlutterDesktopPluginRegistrarRef registrar) {
   FlutterTtsTizenPlugin::RegisterWithRegistrar(
diff --git a/packages/flutter_tts/tizen/src/text_to_speech.cc b/packages/flutter_tts/tizen/src/text_to_speech.cc
index 70a141a71..28ec0e8ba 100644
--- a/packages/flutter_tts/tizen/src/text_to_speech.cc
+++ b/packages/flutter_tts/tizen/src/text_to_speech.cc
@@ -8,55 +8,42 @@
 
 #include "log.h"
 
-namespace {
+TextToSpeech::~TextToSpeech() {
+  UnregisterCallbacks();
 
-void OnStateChanged(tts_h tts, tts_state_e previous, tts_state_e current,
-                    void *user_data) {
-  TextToSpeech *self = static_cast<TextToSpeech *>(user_data);
-  self->OnStateChanged(previous, current);
-}
-
-void OnUtteranceCompleted(tts_h tts, int utt_id, void *user_data) {
-  TextToSpeech *self = static_cast<TextToSpeech *>(user_data);
-  self->OnUtteranceCompleted(utt_id);
-  // Explicitly call stop method to change the tts state to ready.
-  self->Stop();
-}
-
-void OnError(tts_h tts, int utt_id, tts_error_e reason, void *user_data) {
-  TextToSpeech *self = static_cast<TextToSpeech *>(user_data);
-  self->OnError(utt_id, reason);
+  if (tts_) {
+    tts_destroy(tts_);
+    tts_ = nullptr;
+  }
 }
 
-}  // namespace
-
-void TextToSpeech::Init() {
+bool TextToSpeech::Initialize() {
   int ret = tts_create(&tts_);
   if (ret != TTS_ERROR_NONE) {
+    LOG_ERROR("tts_create failed: %s", get_error_message(ret));
     tts_ = nullptr;
-    LOG_ERROR("[TTS] tts_create failed: %s", get_error_message(ret));
+    return false;
   }
-}
 
-void TextToSpeech::Deinit() {
-  if (tts_) {
-    tts_destroy(tts_);
-    tts_ = nullptr;
-  }
+  RegisterCallbacks();
+  Prepare();
+
+  return true;
 }
 
 void TextToSpeech::Prepare() {
   char *language = nullptr;
-  int voice_type = 0;
+  int32_t voice_type = 0;
   int ret = tts_get_default_voice(tts_, &language, &voice_type);
   if (ret == TTS_ERROR_NONE) {
     default_language_ = language;
     default_voice_type_ = voice_type;
     free(language);
   }
+
   ret = sound_manager_get_max_volume(SOUND_TYPE_VOICE, &system_max_volume_);
   if (ret != SOUND_MANAGER_ERROR_NONE) {
-    LOG_ERROR("[SOUNDMANAGER] sound_manager_get_max_volume failed: %s",
+    LOG_ERROR("sound_manager_get_max_volume failed: %s",
               get_error_message(ret));
   }
   system_volume_ = GetSpeechVolumeInternal();
@@ -64,43 +51,60 @@ void TextToSpeech::Prepare() {
 
   ret = tts_prepare(tts_);
   if (ret != TTS_ERROR_NONE) {
-    LOG_ERROR("[TTS] tts_prepare failed: %s", get_error_message(ret));
-  }
-}
-
-void TextToSpeech::RegisterTtsCallback() {
-  tts_set_state_changed_cb(tts_, ::OnStateChanged, (void *)this);
-  tts_set_utterance_completed_cb(tts_, ::OnUtteranceCompleted, (void *)this);
-  tts_set_error_cb(tts_, ::OnError, (void *)this);
-}
-
-void TextToSpeech::UnregisterTtsCallback() {
+    LOG_ERROR("tts_prepare failed: %s", get_error_message(ret));
+  }
+}
+
+void TextToSpeech::RegisterCallbacks() {
+  tts_set_state_changed_cb(
+      tts_,
+      [](tts_h tts, tts_state_e previous, tts_state_e current,
+         void *user_data) {
+        TextToSpeech *self = static_cast<TextToSpeech *>(user_data);
+        self->OnStateChanged(previous, current);
+      },
+      this);
+
+  tts_set_utterance_completed_cb(
+      tts_,
+      [](tts_h tts, int32_t utt_id, void *user_data) {
+        TextToSpeech *self = static_cast<TextToSpeech *>(user_data);
+        self->OnUtteranceCompleted(utt_id);
+        // Explicitly call stop method to change the tts state to ready.
+        self->Stop();
+      },
+      this);
+  tts_set_error_cb(
+      tts_,
+      [](tts_h tts, int32_t utt_id, tts_error_e reason, void *user_data) {
+        TextToSpeech *self = static_cast<TextToSpeech *>(user_data);
+        self->OnError(utt_id, reason);
+      },
+      this);
+}
+
+void TextToSpeech::UnregisterCallbacks() {
   tts_unset_state_changed_cb(tts_);
   tts_unset_utterance_completed_cb(tts_);
   tts_unset_error_cb(tts_);
 }
 
-void TextToSpeech::OnStateChanged(tts_state_e previous, tts_state_e current) {
-  SwitchVolumeOnStateChange(previous, current);
-  on_state_changed_(previous, current);
-}
-
 std::vector<std::string> &TextToSpeech::GetSupportedLanaguages() {
   if (supported_lanaguages_.size() == 0) {
     tts_foreach_supported_voices(
         tts_,
-        [](tts_h tts, const char *language, int voice_type,
+        [](tts_h tts, const char *language, int32_t voice_type,
            void *user_data) -> bool {
           if (language == nullptr) {
             return false;
           }
           TextToSpeech *self = static_cast<TextToSpeech *>(user_data);
           self->supported_lanaguages_.push_back(std::string(language));
-          LOG_INFO("[TTS] Supported Voices - Language(%s), Type(%d)", language,
+          LOG_INFO("Supported Voices - Language(%s), Type(%d)", language,
                    voice_type);
           return true;
         },
-        (void *)this);
+        this);
 
     supported_lanaguages_.erase(
         unique(supported_lanaguages_.begin(), supported_lanaguages_.end()),
@@ -109,20 +113,32 @@ std::vector<std::string> &TextToSpeech::GetSupportedLanaguages() {
   return supported_lanaguages_;
 }
 
-tts_state_e TextToSpeech::GetState() {
+std::optional<TtsState> TextToSpeech::GetState() {
   tts_state_e state;
   int ret = tts_get_state(tts_, &state);
   if (ret != TTS_ERROR_NONE) {
-    LOG_ERROR("[TTS] tts_prepare failed: %s", get_error_message(ret));
+    LOG_ERROR("tts_get_state failed: %s", get_error_message(ret));
+    return std::nullopt;
+  }
+  switch (state) {
+    case TTS_STATE_CREATED:
+      return TtsState::kCreated;
+    case TTS_STATE_READY:
+      return TtsState::kReady;
+    case TTS_STATE_PLAYING:
+      return TtsState::kPlaying;
+    case TTS_STATE_PAUSED:
+      return TtsState::kPaused;
+    default:
+      return std::nullopt;
   }
-  return state;
 }
 
 bool TextToSpeech::AddText(std::string text) {
   int ret = tts_add_text(tts_, text.c_str(), default_language_.c_str(),
                          default_voice_type_, tts_speed_, &utt_id_);
   if (ret != TTS_ERROR_NONE) {
-    LOG_ERROR("[TTS] tts_add_text failed: %s", get_error_message(ret));
+    LOG_ERROR("tts_add_text failed: %s", get_error_message(ret));
     return false;
   }
   return true;
@@ -131,7 +147,7 @@ bool TextToSpeech::AddText(std::string text) {
 bool TextToSpeech::Speak() {
   int ret = tts_play(tts_);
   if (ret != TTS_ERROR_NONE) {
-    LOG_ERROR("[TTS] tts_play failed: %s", get_error_message(ret));
+    LOG_ERROR("tts_play failed: %s", get_error_message(ret));
     return false;
   }
   return true;
@@ -140,7 +156,7 @@ bool TextToSpeech::Speak() {
 bool TextToSpeech::Stop() {
   int ret = tts_stop(tts_);
   if (ret != TTS_ERROR_NONE) {
-    LOG_ERROR("[TTS] tts_stop failed: %s", get_error_message(ret));
+    LOG_ERROR("tts_stop failed: %s", get_error_message(ret));
     return false;
   }
   return true;
@@ -149,16 +165,16 @@ bool TextToSpeech::Stop() {
 bool TextToSpeech::Pause() {
   int ret = tts_pause(tts_);
   if (ret != TTS_ERROR_NONE) {
-    LOG_ERROR("[TTS] tts_pause failed: %s", get_error_message(ret));
+    LOG_ERROR("tts_pause failed: %s", get_error_message(ret));
     return false;
   }
   return true;
 }
 
-bool TextToSpeech::SetVolume(double volume_rate) {
-  tts_volume_ = static_cast<int>(system_max_volume_ * volume_rate);
+bool TextToSpeech::SetVolume(double volume) {
+  tts_volume_ = static_cast<int32_t>(system_max_volume_ * volume);
   // Change volume instantly when tts is playing.
-  if (GetState() == TTS_STATE_PLAYING) {
+  if (GetState() == TtsState::kPlaying) {
     if (!SetSpeechVolumeInternal(tts_volume_)) {
       return false;
     }
@@ -166,10 +182,10 @@ bool TextToSpeech::SetVolume(double volume_rate) {
   return true;
 }
 
-bool TextToSpeech::GetSpeedRange(int *min, int *normal, int *max) {
+bool TextToSpeech::GetSpeedRange(int32_t *min, int32_t *normal, int32_t *max) {
   int ret = tts_get_speed_range(tts_, min, normal, max);
   if (ret != TTS_ERROR_NONE) {
-    LOG_ERROR("[TTS] tts_get_speed_range failed: %s", get_error_message(ret));
+    LOG_ERROR("tts_get_speed_range failed: %s", get_error_message(ret));
     return false;
   }
   return true;
@@ -190,22 +206,20 @@ void TextToSpeech::SwitchVolumeOnStateChange(tts_state_e previous,
   }
 }
 
-int TextToSpeech::GetSpeechVolumeInternal() {
-  int volume;
+int32_t TextToSpeech::GetSpeechVolumeInternal() {
+  int32_t volume;
   int ret = sound_manager_get_volume(SOUND_TYPE_VOICE, &volume);
   if (ret != SOUND_MANAGER_ERROR_NONE) {
-    LOG_ERROR("[SOUNDMANAGER] sound_manager_get_volume failed: %s",
-              get_error_message(ret));
+    LOG_ERROR("sound_manager_get_volume failed: %s", get_error_message(ret));
     volume = 0;
   }
   return volume;
 }
 
-bool TextToSpeech::SetSpeechVolumeInternal(int volume) {
+bool TextToSpeech::SetSpeechVolumeInternal(int32_t volume) {
   int ret = sound_manager_set_volume(SOUND_TYPE_VOICE, volume);
   if (ret != SOUND_MANAGER_ERROR_NONE) {
-    LOG_ERROR("[SOUNDMANAGER] sound_manager_set_volume failed: %s",
-              get_error_message(ret));
+    LOG_ERROR("sound_manager_set_volume failed: %s", get_error_message(ret));
     return false;
   }
   return true;
diff --git a/packages/flutter_tts/tizen/src/text_to_speech.h b/packages/flutter_tts/tizen/src/text_to_speech.h
index e084a431c..77c3fe0d3 100644
--- a/packages/flutter_tts/tizen/src/text_to_speech.h
+++ b/packages/flutter_tts/tizen/src/text_to_speech.h
@@ -8,51 +8,48 @@
 #include <tts.h>
 
 #include <functional>
+#include <optional>
 #include <string>
 #include <vector>
 
-using OnStateChangedCallback =
+enum class TtsState { kCreated, kReady, kPlaying, kPaused };
+
+using StateChangedCallback =
     std::function<void(tts_state_e previous, tts_state_e current)>;
-using OnUtteranceCompletedCallback = std::function<void(int utt_id)>;
-using OnErrorCallback = std::function<void(int utt_id, tts_error_e reason)>;
+using UtteranceCompletedCallback = std::function<void(int32_t utt_id)>;
+using ErrorCallback = std::function<void(int32_t utt_id, tts_error_e reason)>;
 
 class TextToSpeech {
  public:
-  TextToSpeech() {
-    // TODO : Handle initialization failure cases
-    // Rarely, initializing TextToSpeech can fail. IMO, in this case,
-    // we should throw an exception which means that the TextToSpeech instance
-    // creation failed. In addition, we should consider catching the exception
-    // and propagating it to the flutter side. however, I think this is optional
-    // because flutter side is not expecting any errors.
-    Init();
-    RegisterTtsCallback();
-    Prepare();
-  }
+  TextToSpeech() = default;
 
-  ~TextToSpeech() {
-    UnregisterTtsCallback();
-    Deinit();
-  }
+  ~TextToSpeech();
 
-  void SetOnStateChanagedCallback(OnStateChangedCallback callback) {
-    on_state_changed_ = callback;
+  bool Initialize();
+
+  void SetStateChanagedCallback(StateChangedCallback callback) {
+    state_changed_callback_ = callback;
   }
 
-  void SetOnUtteranceCompletedCallback(OnUtteranceCompletedCallback callback) {
-    on_utterance_completed_ = callback;
+  void SetUtteranceCompletedCallback(UtteranceCompletedCallback callback) {
+    utterance_completed_callback_ = callback;
   }
 
-  void SetErrorCallback(OnErrorCallback callback) { on_error_ = callback; }
+  void SetErrorCallback(ErrorCallback callback) { error_callback_ = callback; }
 
-  void OnStateChanged(tts_state_e previous, tts_state_e current);
+  void OnStateChanged(tts_state_e previous, tts_state_e current) {
+    SwitchVolumeOnStateChange(previous, current);
+    state_changed_callback_(previous, current);
+  }
 
-  void OnUtteranceCompleted(int utt_id) {
-    on_utterance_completed_(utt_id);
+  void OnUtteranceCompleted(int32_t utt_id) {
+    utterance_completed_callback_(utt_id);
     ClearUttId();
   }
 
-  void OnError(int utt_id, tts_error_e reason) { on_error_(utt_id, reason); }
+  void OnError(int32_t utt_id, tts_error_e reason) {
+    error_callback_(utt_id, reason);
+  }
 
   std::string GetDefaultLanguage() { return default_language_; }
 
@@ -62,7 +59,7 @@ class TextToSpeech {
 
   std::vector<std::string> &GetSupportedLanaguages();
 
-  tts_state_e GetState();
+  std::optional<TtsState> GetState();
 
   bool AddText(std::string text);
 
@@ -72,40 +69,38 @@ class TextToSpeech {
 
   bool Pause();
 
-  bool SetVolume(double volume_rate);
+  bool SetVolume(double volume);
 
-  bool GetSpeedRange(int *min, int *normal, int *max);
+  bool GetSpeedRange(int32_t *min, int32_t *normal, int32_t *max);
 
-  void SetTtsSpeed(int speed) { tts_speed_ = speed; }
+  void SetTtsSpeed(int32_t speed) { tts_speed_ = speed; }
 
-  int GetUttId() { return utt_id_; }
+  int32_t GetUttId() { return utt_id_; }
 
  private:
-  void Init();
-  void Deinit();
   void Prepare();
-  void RegisterTtsCallback();
-  void UnregisterTtsCallback();
+  void RegisterCallbacks();
+  void UnregisterCallbacks();
   void HandleAwaitSpeakCompletion(tts_state_e previous, tts_state_e current);
   void ClearUttId() { utt_id_ = 0; }
 
   void SwitchVolumeOnStateChange(tts_state_e previous, tts_state_e current);
-  bool SetSpeechVolumeInternal(int volume);
-  int GetSpeechVolumeInternal();
+  bool SetSpeechVolumeInternal(int32_t volume);
+  int32_t GetSpeechVolumeInternal();
 
   tts_h tts_ = nullptr;
   std::string default_language_;
-  int default_voice_type_ = TTS_VOICE_TYPE_AUTO;
-  int tts_speed_ = TTS_SPEED_AUTO;
-  int utt_id_ = 0;
-  int tts_volume_ = 0;
-  int system_volume_ = 0;
-  int system_max_volume_ = 0;
+  int32_t default_voice_type_ = TTS_VOICE_TYPE_AUTO;
+  int32_t tts_speed_ = TTS_SPEED_AUTO;
+  int32_t utt_id_ = 0;
+  int32_t tts_volume_ = 0;
+  int32_t system_volume_ = 0;
+  int32_t system_max_volume_ = 0;
   std::vector<std::string> supported_lanaguages_;
 
-  OnStateChangedCallback on_state_changed_;
-  OnUtteranceCompletedCallback on_utterance_completed_;
-  OnErrorCallback on_error_;
+  StateChangedCallback state_changed_callback_;
+  UtteranceCompletedCallback utterance_completed_callback_;
+  ErrorCallback error_callback_;
 };
 
 #endif  // FLUTTER_PLUGIN_TEXT_TO_SPEACH_H_