diff --git a/packages/video_player_videohole/tizen/project_def.prop b/packages/video_player_videohole/tizen/project_def.prop
index e4b3eb48b..9ea918596 100644
--- a/packages/video_player_videohole/tizen/project_def.prop
+++ b/packages/video_player_videohole/tizen/project_def.prop
@@ -6,7 +6,7 @@ type = staticLib
 profile = common-5.5
 
 # Source files
-USER_SRCS += src/*.cc
+USER_SRCS += src/*.cc src/drm/*.cc
 
 # User defines
 USER_DEFS =
@@ -15,6 +15,6 @@ USER_CPP_DEFS = FLUTTER_PLUGIN_IMPL
 USER_CPP_UNDEFS =
 
 # User includes
-USER_INC_DIRS = inc src
+USER_INC_DIRS = inc src src/drm
 USER_INC_FILES =
 USER_CPP_INC_FILES =
diff --git a/packages/video_player_videohole/tizen/src/drm_license_helper.cc b/packages/video_player_videohole/tizen/src/drm/drm_license_helper.cc
similarity index 100%
rename from packages/video_player_videohole/tizen/src/drm_license_helper.cc
rename to packages/video_player_videohole/tizen/src/drm/drm_license_helper.cc
diff --git a/packages/video_player_videohole/tizen/src/drm_license_helper.h b/packages/video_player_videohole/tizen/src/drm/drm_license_helper.h
similarity index 100%
rename from packages/video_player_videohole/tizen/src/drm_license_helper.h
rename to packages/video_player_videohole/tizen/src/drm/drm_license_helper.h
diff --git a/packages/video_player_videohole/tizen/src/drm/drm_license_request.h b/packages/video_player_videohole/tizen/src/drm/drm_license_request.h
new file mode 100644
index 000000000..e83c00023
--- /dev/null
+++ b/packages/video_player_videohole/tizen/src/drm/drm_license_request.h
@@ -0,0 +1,41 @@
+// Copyright 2023 Samsung Electronics Co., Ltd. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef FLUTTER_PLUGIN_DRM_LICENSE_REQUEST_H_
+#define FLUTTER_PLUGIN_DRM_LICENSE_REQUEST_H_
+
+#include <functional>
+#include <memory>
+#include <string>
+#include <vector>
+
+using OnLicenseRequestDone = std::function<void(
+    const std::string& session_id, const std::vector<uint8_t>& response_data)>;
+
+struct DataForLicenseProcess {
+  DataForLicenseProcess(void* session_id, void* message, int message_length)
+      : session_id(static_cast<char*>(session_id)),
+        message(static_cast<char*>(message), message_length) {}
+  std::string session_id;
+  std::string message;
+};
+class DrmLicenseRequest {
+ public:
+  explicit DrmLicenseRequest(
+      OnLicenseRequestDone on_license_request_done_callback)
+      : on_license_request_done_callback_(on_license_request_done_callback) {}
+  virtual ~DrmLicenseRequest() {}
+  virtual void RequestLicense(void* session_id, int message_type, void* message,
+                              int message_length) = 0;
+  void OnLicenseResponse(const std::string& session_id,
+                         const std::vector<uint8_t>& response_data) {
+    if (on_license_request_done_callback_) {
+      on_license_request_done_callback_(session_id, response_data);
+    }
+  }
+
+ protected:
+  OnLicenseRequestDone on_license_request_done_callback_ = nullptr;
+};
+#endif  // FLUTTER_PLUGIN_DRM_LICENSE_REQUEST_H_
diff --git a/packages/video_player_videohole/tizen/src/drm/drm_license_request_channel.cc b/packages/video_player_videohole/tizen/src/drm/drm_license_request_channel.cc
new file mode 100644
index 000000000..5b2b57e7f
--- /dev/null
+++ b/packages/video_player_videohole/tizen/src/drm/drm_license_request_channel.cc
@@ -0,0 +1,95 @@
+// Copyright 2023 Samsung Electronics Co., Ltd. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "drm_license_request_channel.h"
+
+#include <flutter/method_result_functions.h>
+#include <flutter/standard_method_codec.h>
+
+#include <utility>
+
+#include "log.h"
+
+DrmLicenseRequestChannel::DrmLicenseRequestChannel(
+    flutter::BinaryMessenger *binary_messenger,
+    OnLicenseRequestDone on_license_request_done_callback)
+    : DrmLicenseRequest(on_license_request_done_callback),
+      request_license_channel_(
+          std::make_unique<flutter::MethodChannel<flutter::EncodableValue>>(
+              binary_messenger, "dev.flutter.videoplayer.drm",
+              &flutter::StandardMethodCodec::GetInstance())) {
+  license_request_pipe_ = ecore_pipe_add(
+      [](void *data, void *buffer, unsigned int nbyte) -> void {
+        auto *self = static_cast<DrmLicenseRequestChannel *>(data);
+        self->ExecuteRequest();
+      },
+      this);
+}
+
+void DrmLicenseRequestChannel::RequestLicense(void *session_id,
+                                              int message_type, void *message,
+                                              int message_length) {
+  DataForLicenseProcess process_message(session_id, message, message_length);
+  PushLicenseRequest(process_message);
+}
+
+void DrmLicenseRequestChannel::ExecuteRequest() {
+  std::lock_guard<std::mutex> lock(queue_mutex_);
+  while (!license_request_queue_.empty()) {
+    DataForLicenseProcess data = license_request_queue_.front();
+    RequestLicense(data.session_id, data.message);
+    license_request_queue_.pop();
+  }
+}
+
+void DrmLicenseRequestChannel::PushLicenseRequest(
+    const DataForLicenseProcess &data) {
+  std::lock_guard<std::mutex> lock(queue_mutex_);
+  license_request_queue_.push(data);
+  ecore_pipe_write(license_request_pipe_, nullptr, 0);
+}
+
+void DrmLicenseRequestChannel::RequestLicense(const std::string &session_id,
+                                              const std::string &message) {
+  LOG_INFO("[DrmLicenseRequestChannel] Start request license.");
+
+  if (request_license_channel_ == nullptr) {
+    LOG_ERROR("[DrmLicenseRequestChannel] request license channel is null.");
+    return;
+  }
+
+  std::vector<uint8_t> message_vec(message.begin(), message.end());
+  flutter::EncodableMap args_map = {
+      {flutter::EncodableValue("message"),
+       flutter::EncodableValue(message_vec)},
+  };
+  auto result_handler =
+      std::make_unique<flutter::MethodResultFunctions<flutter::EncodableValue>>(
+
+          [session_id, this](const flutter::EncodableValue *success_value) {
+            std::vector<uint8_t> response;
+            if (std::holds_alternative<std::vector<uint8_t>>(*success_value)) {
+              response = std::get<std::vector<uint8_t>>(*success_value);
+            } else {
+              LOG_ERROR("[DrmLicenseRequestChannel] Fail to get response.");
+              return;
+            }
+            LOG_INFO("[DrmLicenseRequestChannel] Response length : %d",
+                     response.size());
+            OnLicenseResponse(session_id, response);
+          },
+          nullptr, nullptr);
+  request_license_channel_->InvokeMethod(
+      "requestLicense",
+      std::make_unique<flutter::EncodableValue>(
+          flutter::EncodableValue(args_map)),
+      std::move(result_handler));
+}
+
+DrmLicenseRequestChannel::~DrmLicenseRequestChannel() {
+  if (license_request_pipe_) {
+    ecore_pipe_del(license_request_pipe_);
+    license_request_pipe_ = nullptr;
+  }
+}
diff --git a/packages/video_player_videohole/tizen/src/drm/drm_license_request_channel.h b/packages/video_player_videohole/tizen/src/drm/drm_license_request_channel.h
new file mode 100644
index 000000000..d051d83ca
--- /dev/null
+++ b/packages/video_player_videohole/tizen/src/drm/drm_license_request_channel.h
@@ -0,0 +1,39 @@
+// Copyright 2023 Samsung Electronics Co., Ltd. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef FLUTTER_PLUGIN_DRM_LICENSE_REQUEST_CHANNEL_H_
+#define FLUTTER_PLUGIN_DRM_LICENSE_REQUEST_CHANNEL_H_
+
+#include <Ecore.h>
+#include <flutter/method_channel.h>
+
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <string>
+#include <vector>
+
+#include "drm_license_request.h"
+
+class DrmLicenseRequestChannel : public DrmLicenseRequest {
+ public:
+  explicit DrmLicenseRequestChannel(
+      flutter::BinaryMessenger *binary_messenger,
+      OnLicenseRequestDone on_license_request_done_callback);
+  void RequestLicense(void *session_id, int message_type, void *message,
+                      int message_length) override;
+  ~DrmLicenseRequestChannel();
+
+ private:
+  void ExecuteRequest();
+  void PushLicenseRequest(const DataForLicenseProcess &data);
+  void RequestLicense(const std::string &session_id,
+                      const std::string &message);
+  std::unique_ptr<flutter::MethodChannel<flutter::EncodableValue>>
+      request_license_channel_;
+  std::mutex queue_mutex_;
+  Ecore_Pipe *license_request_pipe_ = nullptr;
+  std::queue<DataForLicenseProcess> license_request_queue_;
+};
+#endif
diff --git a/packages/video_player_videohole/tizen/src/drm/drm_license_request_native.cc b/packages/video_player_videohole/tizen/src/drm/drm_license_request_native.cc
new file mode 100644
index 000000000..e910ccbc1
--- /dev/null
+++ b/packages/video_player_videohole/tizen/src/drm/drm_license_request_native.cc
@@ -0,0 +1,178 @@
+// Copyright 2023 Samsung Electronics Co., Ltd. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "drm_license_request_native.h"
+
+#include <string>
+#include <vector>
+
+#include "drm_license_helper.h"
+#include "log.h"
+
+constexpr int kMessageQuit = -1;
+constexpr int kMessageRequestLicense = 0;
+
+struct Message {
+  Eina_Thread_Queue_Msg head;
+  int event;
+  DataForLicenseProcess* data_for_request = nullptr;
+};
+
+LicenseResponsePipe::LicenseResponsePipe(
+    OnLicenseRequestDone on_license_request_done_callback)
+    : on_license_request_done_callback_(on_license_request_done_callback) {
+  license_response_pipe_ = ecore_pipe_add(
+      [](void* data, void* buffer, unsigned int nbyte) -> void {
+        auto* self = static_cast<LicenseResponsePipe*>(data);
+        self->ExecuteResponse();
+      },
+      this);
+}
+
+void LicenseResponsePipe::ExecuteResponse() {
+  std::lock_guard<std::mutex> lock(queue_mutex_);
+  while (!license_response_queue_.empty()) {
+    if (on_license_request_done_callback_) {
+      auto response_data = license_response_queue_.front();
+      on_license_request_done_callback_(response_data.first,
+                                        response_data.second);
+    }
+    license_response_queue_.pop();
+  }
+}
+
+void LicenseResponsePipe::PushLicenseResponse(
+    const std::string& session_id, const std::vector<uint8_t>& response_data) {
+  std::lock_guard<std::mutex> lock(queue_mutex_);
+  license_response_queue_.push(std::make_pair(session_id, response_data));
+  ecore_pipe_write(license_response_pipe_, nullptr, 0);
+}
+
+LicenseResponsePipe::~LicenseResponsePipe() {
+  if (license_response_pipe_) {
+    ecore_pipe_del(license_response_pipe_);
+    license_response_pipe_ = nullptr;
+  }
+}
+
+DrmLicenseRequestNative::DrmLicenseRequestNative(
+    int drm_type, const std::string& license_server_url,
+    OnLicenseRequestDone on_license_request_done_callback)
+    : DrmLicenseRequest(on_license_request_done_callback),
+      drm_type_(drm_type),
+      license_server_url_(license_server_url) {
+  license_response_pipe_ = std::make_shared<LicenseResponsePipe>(
+      [this](const std::string& session_id,
+             const std::vector<uint8_t>& response_data) {
+        OnLicenseResponse(session_id, response_data);
+      });
+  license_request_thread_ = ecore_thread_feedback_run(RunLoop, nullptr, nullptr,
+                                                      nullptr, this, EINA_TRUE);
+}
+
+void DrmLicenseRequestNative::RequestLicense(void* session_id, int message_type,
+                                             void* message,
+                                             int message_length) {
+  if (!license_request_thread_ || ecore_thread_check(license_request_thread_)) {
+    LOG_ERROR("Invalid license request thread.");
+    return;
+  }
+
+  if (!license_request_queue_) {
+    LOG_ERROR("Invalid license request thread queue.");
+    return;
+  }
+
+  void* ref;
+  Message* request_message = static_cast<Message*>(
+      eina_thread_queue_send(license_request_queue_, sizeof(Message), &ref));
+  request_message->event = kMessageRequestLicense;
+  request_message->data_for_request =
+      new DataForLicenseProcess(session_id, message, message_length);
+  eina_thread_queue_send_done(license_request_queue_, ref);
+}
+
+void DrmLicenseRequestNative::StopMessageQueue() {
+  if (!license_request_thread_ || ecore_thread_check(license_request_thread_)) {
+    LOG_ERROR("Invalid license request thread.");
+    return;
+  }
+
+  if (!license_request_queue_) {
+    LOG_ERROR("Invalid license request thread queue.");
+    return;
+  }
+
+  void* ref;
+  Message* message = static_cast<Message*>(
+      eina_thread_queue_send(license_request_queue_, sizeof(Message), &ref));
+  message->event = kMessageQuit;
+  eina_thread_queue_send_done(license_request_queue_, ref);
+}
+
+void DrmLicenseRequestNative::RunLoop(void* data, Ecore_Thread* thread) {
+  Eina_Thread_Queue* license_request_queue = eina_thread_queue_new();
+  if (!license_request_queue) {
+    LOG_ERROR("Invalid license request thread queue.");
+    ecore_thread_cancel(thread);
+    return;
+  }
+  auto* self = static_cast<DrmLicenseRequestNative*>(data);
+  self->license_request_queue_ = license_request_queue;
+  std::weak_ptr<LicenseResponsePipe> weak_pipe = self->license_response_pipe_;
+  std::string license_server_url = self->license_server_url_;
+  int drm_type = self->drm_type_;
+  while (!ecore_thread_check(thread)) {
+    void* ref;
+    Message* message = static_cast<Message*>(
+        eina_thread_queue_wait(license_request_queue, &ref));
+    if (message->event == kMessageQuit) {
+      LOG_DEBUG("Receive kMessageQuit message");
+      eina_thread_queue_wait_done(license_request_queue, ref);
+      break;
+    }
+    if (message->data_for_request == nullptr) {
+      LOG_ERROR("data_for_request is null");
+      continue;
+    }
+    std::string challenge = message->data_for_request->message;
+    std::string session_id = message->data_for_request->session_id;
+    delete message->data_for_request;
+    eina_thread_queue_wait_done(license_request_queue, ref);
+    // Get license via the license server.
+    unsigned char* response_data = nullptr;
+    unsigned long response_len = 0;
+    std::vector<uint8_t> response;
+    DRM_RESULT ret = DrmLicenseHelper::DoTransactionTZ(
+        license_server_url.c_str(), challenge.c_str(), challenge.size(),
+        &response_data, &response_len,
+        static_cast<DrmLicenseHelper::DrmType>(drm_type), nullptr, nullptr);
+
+    if (DRM_SUCCESS != ret || nullptr == response_data || 0 == response_len) {
+      LOG_ERROR("Fail to get respone by license server url.");
+      continue;
+    }
+    LOG_INFO("Response length : %lu", response_len);
+    if (weak_pipe.expired()) {
+      LOG_DEBUG("weak_pipe expired");
+      free(response_data);
+      break;
+    }
+    auto response_vec =
+        std::vector<uint8_t>(response_data, response_data + response_len);
+    weak_pipe.lock()->PushLicenseResponse(session_id, response_vec);
+    free(response_data);
+  }
+  if (license_request_queue) {
+    eina_thread_queue_free(license_request_queue);
+  }
+}
+
+DrmLicenseRequestNative::~DrmLicenseRequestNative() {
+  StopMessageQueue();
+  if (license_request_thread_) {
+    ecore_thread_cancel(license_request_thread_);
+    license_request_thread_ = nullptr;
+  }
+}
diff --git a/packages/video_player_videohole/tizen/src/drm/drm_license_request_native.h b/packages/video_player_videohole/tizen/src/drm/drm_license_request_native.h
new file mode 100644
index 000000000..171016f05
--- /dev/null
+++ b/packages/video_player_videohole/tizen/src/drm/drm_license_request_native.h
@@ -0,0 +1,54 @@
+// Copyright 2023 Samsung Electronics Co., Ltd. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+#ifndef FLUTTER_PLUGIN_DRM_LICENSE_REQUEST_NATIVE_H_
+#define FLUTTER_PLUGIN_DRM_LICENSE_REQUEST_NATIVE_H_
+
+#include <Ecore.h>
+
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "drm_license_request.h"
+
+class LicenseResponsePipe {
+ public:
+  explicit LicenseResponsePipe(
+      OnLicenseRequestDone on_license_request_done_callback);
+  virtual ~LicenseResponsePipe();
+  void ExecuteResponse();
+  void PushLicenseResponse(const std::string& session_id,
+                           const std::vector<uint8_t>& response_data);
+
+ private:
+  std::mutex queue_mutex_;
+  Ecore_Pipe* license_response_pipe_ = nullptr;
+  std::queue<std::pair<std::string, std::vector<uint8_t>>>
+      license_response_queue_;
+  OnLicenseRequestDone on_license_request_done_callback_ = nullptr;
+};
+
+class DrmLicenseRequestNative : public DrmLicenseRequest {
+ public:
+  explicit DrmLicenseRequestNative(
+      int drm_type, const std::string& license_server_url,
+      OnLicenseRequestDone on_license_request_done_callback);
+  virtual ~DrmLicenseRequestNative();
+  void RequestLicense(void* session_id, int message_type, void* message,
+                      int message_length) override;
+
+ private:
+  static void RunLoop(void* data, Ecore_Thread* thread);
+  void StopMessageQueue();
+  int drm_type_;
+  Ecore_Thread* license_request_thread_ = nullptr;
+  Eina_Thread_Queue* license_request_queue_ = nullptr;
+  std::string license_server_url_;
+  std::shared_ptr<LicenseResponsePipe> license_response_pipe_;
+};
+
+#endif
diff --git a/packages/video_player_videohole/tizen/src/drm_manager.cc b/packages/video_player_videohole/tizen/src/drm/drm_manager.cc
similarity index 65%
rename from packages/video_player_videohole/tizen/src/drm_manager.cc
rename to packages/video_player_videohole/tizen/src/drm/drm_manager.cc
index 3d695b01e..0fcc70028 100644
--- a/packages/video_player_videohole/tizen/src/drm_manager.cc
+++ b/packages/video_player_videohole/tizen/src/drm/drm_manager.cc
@@ -8,6 +8,8 @@
 #include <flutter/standard_method_codec.h>
 
 #include "drm_license_helper.h"
+#include "drm_license_request_channel.h"
+#include "drm_license_request_native.h"
 #include "drm_manager_proxy.h"
 #include "log.h"
 
@@ -34,19 +36,10 @@ DrmManager::DrmManager() : drm_type_(DM_TYPE_NONE) {
   } else {
     LOG_ERROR("[DrmManager] Fail to dlopen libdrmmanager.");
   }
-  license_request_pipe_ = ecore_pipe_add(
-      [](void *data, void *buffer, unsigned int nbyte) -> void {
-        auto *self = static_cast<DrmManager *>(data);
-        self->ExecuteRequest();
-      },
-      this);
 }
 
 DrmManager::~DrmManager() {
   ReleaseDrmSession();
-  if (license_request_pipe_) {
-    ecore_pipe_del(license_request_pipe_);
-  }
   if (drm_manager_proxy_) {
     CloseDrmManagerProxy(drm_manager_proxy_);
     drm_manager_proxy_ = nullptr;
@@ -91,16 +84,23 @@ bool DrmManager::CreateDrmSession(int drm_type, bool local_mode) {
 
 bool DrmManager::SetChallenge(const std::string &media_url,
                               flutter::BinaryMessenger *binary_messenger) {
-  request_license_channel_ =
-      std::make_unique<flutter::MethodChannel<flutter::EncodableValue>>(
-          binary_messenger, "dev.flutter.videoplayer.drm",
-          &flutter::StandardMethodCodec::GetInstance());
+  drm_license_request_ = std::make_unique<DrmLicenseRequestChannel>(
+      binary_messenger, [this](const std::string &session_id,
+                               const std::vector<uint8_t> &response_data) {
+        InstallKey(session_id, response_data);
+      });
   return DM_ERROR_NONE == SetChallenge(media_url);
 }
 
 bool DrmManager::SetChallenge(const std::string &media_url,
                               const std::string &license_server_url) {
   license_server_url_ = license_server_url;
+  drm_license_request_ = std::make_unique<DrmLicenseRequestNative>(
+      drm_type_, license_server_url,
+      [this](const std::string &session_id,
+             const std::vector<uint8_t> &response_data) {
+        InstallKey(session_id, response_data);
+      });
   return DM_ERROR_NONE == SetChallenge(media_url);
 }
 
@@ -231,8 +231,8 @@ int DrmManager::OnChallengeData(void *session_id, int message_type,
   DrmManager *self = static_cast<DrmManager *>(user_data);
   LOG_INFO("[DrmManager] drm_type: %d, license server: %s", self->drm_type_,
            self->license_server_url_.c_str());
-  DataForLicenseProcess process_message(session_id, message, message_length);
-  self->PushLicenseRequestData(process_message);
+  self->drm_license_request_->RequestLicense(session_id, message_type, message,
+                                             message_length);
   return DM_ERROR_NONE;
 }
 
@@ -242,99 +242,18 @@ void DrmManager::OnDrmManagerError(long error_code, char *error_message,
             error_message);
 }
 
-bool DrmManager::ProcessLicense(DataForLicenseProcess &data) {
-  LOG_INFO("[DrmManager] Start process license.");
-
-  if (!license_server_url_.empty()) {
-    // Get license via the license server.
-    unsigned char *response_data = nullptr;
-    unsigned long response_len = 0;
-    DRM_RESULT ret = DrmLicenseHelper::DoTransactionTZ(
-        license_server_url_.c_str(), data.message.c_str(), data.message.size(),
-        &response_data, &response_len,
-        static_cast<DrmLicenseHelper::DrmType>(drm_type_), nullptr, nullptr);
-    if (DRM_SUCCESS != ret || nullptr == response_data || 0 == response_len) {
-      LOG_ERROR("[DrmManager] Fail to get respone by license server url.");
-      return false;
-    }
-    LOG_INFO("[DrmManager] Response length : %lu", response_len);
-    InstallKey(const_cast<void *>(
-                   reinterpret_cast<const void *>(data.session_id.c_str())),
-               static_cast<void *>(response_data),
-               reinterpret_cast<void *>(response_len));
-  } else if (request_license_channel_) {
-    // Get license via the Dart callback.
-    RequestLicense(data.session_id, data.message);
-  } else {
-    LOG_ERROR("[DrmManager] No way to request license.");
-  }
-  return false;
-}
-
-void DrmManager::InstallKey(void *session_id, void *response_data,
-                            void *response_len) {
+void DrmManager::InstallKey(const std::string &session_id,
+                            const std::vector<uint8_t> &response) {
   LOG_INFO("[DrmManager] Start install license.");
 
   SetDataParam_t license_param = {};
-  license_param.param1 = session_id;
-  license_param.param2 = response_data;
-  license_param.param3 = response_len;
+  license_param.param1 =
+      reinterpret_cast<void *>(const_cast<char *>(session_id.c_str()));
+  license_param.param2 = const_cast<uint8_t *>(response.data());
+  license_param.param3 = reinterpret_cast<void *>(response.size());
   int ret = DMGRSetData(drm_session_, "install_eme_key", &license_param);
   if (ret != DM_ERROR_NONE) {
     LOG_ERROR("[DrmManager] Fail to install eme key: %s",
               get_error_message(ret));
   }
 }
-
-void DrmManager::RequestLicense(std::string &session_id, std::string &message) {
-  LOG_INFO("[DrmManager] Start request license.");
-
-  if (request_license_channel_ == nullptr) {
-    LOG_ERROR("[DrmManager] request license channel is null.");
-    return;
-  }
-
-  std::vector<uint8_t> message_vec(message.begin(), message.end());
-  flutter::EncodableMap args_map = {
-      {flutter::EncodableValue("message"),
-       flutter::EncodableValue(message_vec)},
-  };
-  auto result_handler =
-      std::make_unique<flutter::MethodResultFunctions<flutter::EncodableValue>>(
-
-          [session_id, this](const flutter::EncodableValue *success_value) {
-            std::vector<uint8_t> response;
-            if (std::holds_alternative<std::vector<uint8_t>>(*success_value)) {
-              response = std::get<std::vector<uint8_t>>(*success_value);
-            } else {
-              LOG_ERROR("[DrmManager] Fail to get response.");
-              return;
-            }
-            LOG_INFO("[DrmManager] Response length : %d", response.size());
-            InstallKey(const_cast<void *>(
-                           reinterpret_cast<const void *>(session_id.c_str())),
-                       reinterpret_cast<void *>(response.data()),
-                       reinterpret_cast<void *>(response.size()));
-          },
-          nullptr, nullptr);
-  request_license_channel_->InvokeMethod(
-      "requestLicense",
-      std::make_unique<flutter::EncodableValue>(
-          flutter::EncodableValue(args_map)),
-      std::move(result_handler));
-}
-
-void DrmManager::PushLicenseRequestData(DataForLicenseProcess &data) {
-  std::lock_guard<std::mutex> lock(queue_mutex_);
-  license_request_queue_.push(data);
-  ecore_pipe_write(license_request_pipe_, nullptr, 0);
-}
-
-void DrmManager::ExecuteRequest() {
-  std::lock_guard<std::mutex> lock(queue_mutex_);
-  while (!license_request_queue_.empty()) {
-    DataForLicenseProcess data = license_request_queue_.front();
-    ProcessLicense(data);
-    license_request_queue_.pop();
-  }
-}
diff --git a/packages/video_player_videohole/tizen/src/drm_manager.h b/packages/video_player_videohole/tizen/src/drm/drm_manager.h
similarity index 66%
rename from packages/video_player_videohole/tizen/src/drm_manager.h
rename to packages/video_player_videohole/tizen/src/drm/drm_manager.h
index c8113d96f..6f95580e5 100644
--- a/packages/video_player_videohole/tizen/src/drm_manager.h
+++ b/packages/video_player_videohole/tizen/src/drm/drm_manager.h
@@ -11,6 +11,7 @@
 #include <mutex>
 #include <queue>
 
+#include "drm_license_request.h"
 #include "drm_manager_proxy.h"
 
 class DrmManager {
@@ -36,28 +37,14 @@ class DrmManager {
   void ReleaseDrmSession();
 
  private:
-  struct DataForLicenseProcess {
-    DataForLicenseProcess(void *session_id, void *message, int message_length)
-        : session_id(static_cast<char *>(session_id)),
-          message(static_cast<char *>(message), message_length) {}
-    std::string session_id;
-    std::string message;
-  };
-
-  void RequestLicense(std::string &session_id, std::string &message);
-  void InstallKey(void *session_id, void *response_data, void *response_len);
+  void InstallKey(const std::string &session_id,
+                  const std::vector<uint8_t> &response);
   int SetChallenge(const std::string &media_url);
 
   static int OnChallengeData(void *session_id, int message_type, void *message,
                              int message_length, void *user_data);
   static void OnDrmManagerError(long error_code, char *error_message,
                                 void *user_data);
-  bool ProcessLicense(DataForLicenseProcess &data);
-  void PushLicenseRequestData(DataForLicenseProcess &data);
-  void ExecuteRequest();
-
-  std::unique_ptr<flutter::MethodChannel<flutter::EncodableValue>>
-      request_license_channel_;
 
   void *drm_session_ = nullptr;
   void *drm_manager_proxy_ = nullptr;
@@ -65,9 +52,8 @@ class DrmManager {
   int drm_type_;
   std::string license_server_url_;
   bool initialized_ = false;
-  std::mutex queue_mutex_;
-  Ecore_Pipe *license_request_pipe_ = nullptr;
-  std::queue<DataForLicenseProcess> license_request_queue_;
+
+  std::unique_ptr<DrmLicenseRequest> drm_license_request_;
 };
 
 #endif  // FLUTTER_PLUGIN_DRM_MANAGER_H_
diff --git a/packages/video_player_videohole/tizen/src/drm_manager_proxy.cc b/packages/video_player_videohole/tizen/src/drm/drm_manager_proxy.cc
similarity index 100%
rename from packages/video_player_videohole/tizen/src/drm_manager_proxy.cc
rename to packages/video_player_videohole/tizen/src/drm/drm_manager_proxy.cc
diff --git a/packages/video_player_videohole/tizen/src/drm_manager_proxy.h b/packages/video_player_videohole/tizen/src/drm/drm_manager_proxy.h
similarity index 100%
rename from packages/video_player_videohole/tizen/src/drm_manager_proxy.h
rename to packages/video_player_videohole/tizen/src/drm/drm_manager_proxy.h
diff --git a/packages/video_player_videohole/tizen/src/video_player.h b/packages/video_player_videohole/tizen/src/video_player.h
index 53c1ebd92..fc5c86b44 100644
--- a/packages/video_player_videohole/tizen/src/video_player.h
+++ b/packages/video_player_videohole/tizen/src/video_player.h
@@ -37,8 +37,8 @@ class VideoPlayer {
   virtual void SetDisplayRoi(int32_t x, int32_t y, int32_t width,
                              int32_t height) = 0;
   virtual bool Play() = 0;
-  virtual bool Deactivate() { return false; };
-  virtual bool Activate() { return false; };
+  virtual bool Deactivate() { return false; }
+  virtual bool Activate() { return false; }
   virtual bool Pause() = 0;
   virtual bool SetLooping(bool is_looping) = 0;
   virtual bool SetVolume(double volume) = 0;