diff --git a/packages/flutter_webrtc/CHANGELOG.md b/packages/flutter_webrtc/CHANGELOG.md
index 607323422..8cd603c03 100644
--- a/packages/flutter_webrtc/CHANGELOG.md
+++ b/packages/flutter_webrtc/CHANGELOG.md
@@ -1,3 +1,8 @@
+## 0.1.1
+
+* Update flutter_webrtc to 0.9.23.
+* Fix coredump issue when exit app.
+
 ## 0.1.0
 
 * Initial release.
diff --git a/packages/flutter_webrtc/README.md b/packages/flutter_webrtc/README.md
index 45934331b..aa6b7e943 100644
--- a/packages/flutter_webrtc/README.md
+++ b/packages/flutter_webrtc/README.md
@@ -40,8 +40,8 @@ For other Tizen devices :
 
  ```yaml
 dependencies:
-  flutter_webrtc: ^0.9.18
-  flutter_webrtc_tizen: ^0.1.0
+  flutter_webrtc: ^0.9.23
+  flutter_webrtc_tizen: ^0.1.1
 ```
 
 ## Functionality
diff --git a/packages/flutter_webrtc/example/flutter_webrtc_demo/pubspec.yaml b/packages/flutter_webrtc/example/flutter_webrtc_demo/pubspec.yaml
index 4ce592a0d..ebfd46a67 100644
--- a/packages/flutter_webrtc/example/flutter_webrtc_demo/pubspec.yaml
+++ b/packages/flutter_webrtc/example/flutter_webrtc_demo/pubspec.yaml
@@ -11,7 +11,7 @@ dependencies:
   cupertino_icons: ^1.0.3
   flutter:
     sdk: flutter
-  flutter_webrtc: ^0.9.18
+  flutter_webrtc: ^0.9.23
   flutter_webrtc_tizen:
     path: ../../
   http: ^0.13.3
diff --git a/packages/flutter_webrtc/example/flutter_webrtc_example/pubspec.yaml b/packages/flutter_webrtc/example/flutter_webrtc_example/pubspec.yaml
index fa885f602..72bf9fd6f 100644
--- a/packages/flutter_webrtc/example/flutter_webrtc_example/pubspec.yaml
+++ b/packages/flutter_webrtc/example/flutter_webrtc_example/pubspec.yaml
@@ -12,7 +12,7 @@ dependencies:
   flutter:
     sdk: flutter
   flutter_background: ^1.0.0
-  flutter_webrtc: ^0.9.18
+  flutter_webrtc: ^0.9.23
   flutter_webrtc_tizen:
     path: ../../
   # Required for MediaRecorder example
diff --git a/packages/flutter_webrtc/pubspec.yaml b/packages/flutter_webrtc/pubspec.yaml
index 96ed2bbc0..22ee6e241 100644
--- a/packages/flutter_webrtc/pubspec.yaml
+++ b/packages/flutter_webrtc/pubspec.yaml
@@ -2,7 +2,7 @@ name: flutter_webrtc_tizen
 homepage: https://github.com/flutter-tizen/plugins
 description: Flutter WebRTC plugin for Tizen, based on GoogleWebRTC.
 repository: https://github.com/flutter-tizen/plugins/tree/master/packages/flutter_webrtc
-version: 0.1.0
+version: 0.1.1
 
 flutter:
   plugin:
diff --git a/packages/flutter_webrtc/tizen/inc/flutter_peerconnection.h b/packages/flutter_webrtc/tizen/inc/flutter_peerconnection.h
index a8567b417..0804ec74b 100644
--- a/packages/flutter_webrtc/tizen/inc/flutter_peerconnection.h
+++ b/packages/flutter_webrtc/tizen/inc/flutter_peerconnection.h
@@ -75,7 +75,7 @@ class FlutterPeerConnection {
                            std::unique_ptr<MethodResultProxy> result);
 
   void GetRemoteDescription(RTCPeerConnection* pc,
-                            std::unique_ptr<MethodResultProxy> resulte);
+                            std::unique_ptr<MethodResultProxy> result);
 
   scoped_refptr<RTCRtpTransceiverInit> mapToRtpTransceiverInit(
       const EncodableMap& transceiverInit);
@@ -89,45 +89,42 @@ class FlutterPeerConnection {
   void AddTransceiver(RTCPeerConnection* pc, const std::string& trackId,
                       const std::string& mediaType,
                       const EncodableMap& transceiverInit,
-                      std::unique_ptr<MethodResultProxy> resulte);
+                      std::unique_ptr<MethodResultProxy> result);
 
   void GetTransceivers(RTCPeerConnection* pc,
-                       std::unique_ptr<MethodResultProxy> resulte);
+                       std::unique_ptr<MethodResultProxy> result);
 
   void GetReceivers(RTCPeerConnection* pc,
-                    std::unique_ptr<MethodResultProxy> resulte);
-
-  void RtpSenderDispose(RTCPeerConnection* pc, std::string rtpSenderId,
-                        std::unique_ptr<MethodResultProxy> resulte);
+                    std::unique_ptr<MethodResultProxy> result);
 
   void RtpSenderSetTrack(RTCPeerConnection* pc, RTCMediaTrack* track,
                          std::string rtpSenderId,
-                         std::unique_ptr<MethodResultProxy> resulte);
+                         std::unique_ptr<MethodResultProxy> result);
 
   void RtpSenderReplaceTrack(RTCPeerConnection* pc, RTCMediaTrack* track,
                              std::string rtpSenderId,
-                             std::unique_ptr<MethodResultProxy> resulte);
+                             std::unique_ptr<MethodResultProxy> result);
 
   scoped_refptr<RTCRtpParameters> updateRtpParameters(
       EncodableMap newParameters, scoped_refptr<RTCRtpParameters> parameters);
 
   void RtpSenderSetParameters(RTCPeerConnection* pc, std::string rtpSenderId,
                               const EncodableMap& parameters,
-                              std::unique_ptr<MethodResultProxy> resulte);
+                              std::unique_ptr<MethodResultProxy> result);
 
   void RtpTransceiverStop(RTCPeerConnection* pc, std::string rtpTransceiverId,
-                          std::unique_ptr<MethodResultProxy> resulte);
+                          std::unique_ptr<MethodResultProxy> result);
 
   void RtpTransceiverGetCurrentDirection(
       RTCPeerConnection* pc, std::string rtpTransceiverId,
-      std::unique_ptr<MethodResultProxy> resulte);
+      std::unique_ptr<MethodResultProxy> result);
 
   void SetConfiguration(RTCPeerConnection* pc,
                         const EncodableMap& configuration,
-                        std::unique_ptr<MethodResultProxy> resulte);
+                        std::unique_ptr<MethodResultProxy> result);
 
   void CaptureFrame(RTCVideoTrack* track, std::string path,
-                    std::unique_ptr<MethodResultProxy> resulte);
+                    std::unique_ptr<MethodResultProxy> result);
 
   scoped_refptr<RTCRtpTransceiver> getRtpTransceiverById(RTCPeerConnection* pc,
                                                          std::string id);
@@ -135,10 +132,14 @@ class FlutterPeerConnection {
   void RtpTransceiverSetDirection(RTCPeerConnection* pc,
                                   std::string rtpTransceiverId,
                                   std::string direction,
-                                  std::unique_ptr<MethodResultProxy> resulte);
+                                  std::unique_ptr<MethodResultProxy> result);
+
+  void RtpTransceiverSetCodecPreferences(
+      RTCPeerConnection* pc, std::string rtpTransceiverId,
+      const EncodableList codecs, std::unique_ptr<MethodResultProxy> result);
 
   void GetSenders(RTCPeerConnection* pc,
-                  std::unique_ptr<MethodResultProxy> resulte);
+                  std::unique_ptr<MethodResultProxy> result);
 
   void AddIceCandidate(RTCIceCandidate* candidate, RTCPeerConnection* pc,
                        std::unique_ptr<MethodResultProxy> result);
diff --git a/packages/flutter_webrtc/tizen/lib/aarch64/libwebrtc.so b/packages/flutter_webrtc/tizen/lib/aarch64/libwebrtc.so
index ac10f2846..160625d1d 100755
Binary files a/packages/flutter_webrtc/tizen/lib/aarch64/libwebrtc.so and b/packages/flutter_webrtc/tizen/lib/aarch64/libwebrtc.so differ
diff --git a/packages/flutter_webrtc/tizen/lib/armel/libwebrtc.so b/packages/flutter_webrtc/tizen/lib/armel/libwebrtc.so
index 028e02279..46c39c6c6 100755
Binary files a/packages/flutter_webrtc/tizen/lib/armel/libwebrtc.so and b/packages/flutter_webrtc/tizen/lib/armel/libwebrtc.so differ
diff --git a/packages/flutter_webrtc/tizen/lib/i586/libwebrtc.so b/packages/flutter_webrtc/tizen/lib/i586/libwebrtc.so
index 4f81a2b40..be5281e44 100755
Binary files a/packages/flutter_webrtc/tizen/lib/i586/libwebrtc.so and b/packages/flutter_webrtc/tizen/lib/i586/libwebrtc.so differ
diff --git a/packages/flutter_webrtc/tizen/src/flutter_common.cc b/packages/flutter_webrtc/tizen/src/flutter_common.cc
index 60829414a..a92b15a79 100644
--- a/packages/flutter_webrtc/tizen/src/flutter_common.cc
+++ b/packages/flutter_webrtc/tizen/src/flutter_common.cc
@@ -7,7 +7,7 @@
 
 class MethodCallProxyImpl : public MethodCallProxy {
  public:
-  MethodCallProxyImpl(const MethodCall& method_call)
+  explicit MethodCallProxyImpl(const MethodCall& method_call)
       : method_call_(method_call) {}
 
   ~MethodCallProxyImpl() {}
@@ -34,7 +34,7 @@ std::unique_ptr<MethodCallProxy> MethodCallProxy::Create(
 
 class MethodResultProxyImpl : public MethodResultProxy {
  public:
-  MethodResultProxyImpl(std::unique_ptr<MethodResult> method_result)
+  explicit MethodResultProxyImpl(std::unique_ptr<MethodResult> method_result)
       : method_result_(std::move(method_result)) {}
   ~MethodResultProxyImpl() {}
 
diff --git a/packages/flutter_webrtc/tizen/src/flutter_media_stream.cc b/packages/flutter_webrtc/tizen/src/flutter_media_stream.cc
index 9953d38c4..baa3a2c94 100644
--- a/packages/flutter_webrtc/tizen/src/flutter_media_stream.cc
+++ b/packages/flutter_webrtc/tizen/src/flutter_media_stream.cc
@@ -301,8 +301,8 @@ void FlutterMediaStream::GetSources(std::unique_ptr<MethodResultProxy> result) {
   EncodableList sources;
 
   int nb_audio_devices = base_->audio_device_->RecordingDevices();
-  char strNameUTF8[128];
-  char strGuidUTF8[128];
+  char strNameUTF8[RTCAudioDevice::kAdmMaxDeviceNameSize + 1] = {0};
+  char strGuidUTF8[RTCAudioDevice::kAdmMaxGuidSize + 1] = {0};
 
   for (uint16_t i = 0; i < nb_audio_devices; i++) {
     base_->audio_device_->RecordingDeviceName(i, strNameUTF8, strGuidUTF8);
diff --git a/packages/flutter_webrtc/tizen/src/flutter_peerconnection.cc b/packages/flutter_webrtc/tizen/src/flutter_peerconnection.cc
index b45b81b89..dac27e81f 100644
--- a/packages/flutter_webrtc/tizen/src/flutter_peerconnection.cc
+++ b/packages/flutter_webrtc/tizen/src/flutter_peerconnection.cc
@@ -79,10 +79,11 @@ EncodableMap rtpParametersToMap(
     map[EncodableValue("minBitrate")] =
         EncodableValue(encoding->min_bitrate_bps());
     map[EncodableValue("maxFramerate")] =
-        EncodableValue(encoding->max_framerate());
+        EncodableValue(static_cast<int>(encoding->max_framerate()));
     map[EncodableValue("scaleResolutionDownBy")] =
         EncodableValue(encoding->scale_resolution_down_by());
-    map[EncodableValue("ssrc")] = EncodableValue((int)encoding->ssrc());
+    map[EncodableValue("ssrc")] =
+        EncodableValue(static_cast<int>(encoding->ssrc()));
     encodings_info.push_back(EncodableValue(map));
   }
   info[EncodableValue("encodings")] = EncodableValue(encodings_info);
@@ -519,27 +520,13 @@ void FlutterPeerConnection::GetReceivers(
   result_ptr->Success(EncodableValue(map));
 }
 
-void FlutterPeerConnection::RtpSenderDispose(
-    RTCPeerConnection* pc, std::string rtpSenderId,
-    std::unique_ptr<MethodResultProxy> result) {
-  std::shared_ptr<MethodResultProxy> result_ptr(result.release());
-
-  auto sender = GetRtpSenderById(pc, rtpSenderId);
-  if (nullptr == sender.get()) {
-    result_ptr->Error("rtpSenderDispose", "sender is null");
-    return;
-  }
-  // TODO RtpSenderDispose
-  result_ptr->Success();
-}
-
 void FlutterPeerConnection::RtpSenderSetTrack(
     RTCPeerConnection* pc, RTCMediaTrack* track, std::string rtpSenderId,
     std::unique_ptr<MethodResultProxy> result) {
   std::shared_ptr<MethodResultProxy> result_ptr(result.release());
   auto sender = GetRtpSenderById(pc, rtpSenderId);
   if (nullptr == sender.get()) {
-    result_ptr->Error("rtpSenderDispose", "sender is null");
+    result_ptr->Error("rtpSenderSetTrack", "sender is null");
     return;
   }
   sender->set_track(track);
@@ -552,7 +539,7 @@ void FlutterPeerConnection::RtpSenderReplaceTrack(
   std::shared_ptr<MethodResultProxy> result_ptr(result.release());
   auto sender = GetRtpSenderById(pc, rtpSenderId);
   if (nullptr == sender.get()) {
-    result_ptr->Error("rtpSenderDispose", "sender is null");
+    result_ptr->Error("rtpSenderReplaceTrack", "sender is null");
     return;
   }
 
@@ -611,15 +598,17 @@ void FlutterPeerConnection::RtpSenderSetParameters(
 
   auto sender = GetRtpSenderById(pc, rtpSenderId);
   if (nullptr == sender.get()) {
-    result_ptr->Error("rtpSenderDispose", "sender is null");
+    result_ptr->Error("rtpSenderSetParameters", "sender is null");
     return;
   }
 
   auto param = sender->parameters();
   param = updateRtpParameters(parameters, param);
-  sender->set_parameters(param);
+  bool success = sender->set_parameters(param);
 
-  result_ptr->Success();
+  EncodableMap map;
+  map[EncodableValue("result")] = EncodableValue(success);
+  result_ptr->Success(EncodableValue(map));
 }
 
 void FlutterPeerConnection::RtpTransceiverStop(
@@ -703,6 +692,35 @@ void FlutterPeerConnection::RtpTransceiverSetDirection(
   }
 }
 
+void FlutterPeerConnection::RtpTransceiverSetCodecPreferences(
+    RTCPeerConnection* pc, std::string rtpTransceiverId,
+    const EncodableList codecs, std::unique_ptr<MethodResultProxy> result) {
+  std::shared_ptr<MethodResultProxy> result_ptr(result.release());
+  auto transceiver = getRtpTransceiverById(pc, rtpTransceiverId);
+  if (nullptr == transceiver.get()) {
+    result_ptr->Error("RtpTransceiverSetCodecPreferences",
+                      " transceiver is null ");
+    return;
+  }
+  std::vector<scoped_refptr<RTCRtpCodecCapability>> codecList;
+  for (auto codec : codecs) {
+    auto codecMap = GetValue<EncodableMap>(codec);
+    auto codecMimeType = findString(codecMap, "mimeType");
+    auto codecClockRate = findInt(codecMap, "clockRate");
+    auto codecNumChannels = findInt(codecMap, "channels");
+    auto codecSdpFmtpLine = findString(codecMap, "sdpFmtpLine");
+    auto codecCapability = RTCRtpCodecCapability::Create();
+    if (codecSdpFmtpLine != std::string())
+      codecCapability->set_sdp_fmtp_line(codecSdpFmtpLine);
+    codecCapability->set_clock_rate(codecClockRate);
+    if (codecNumChannels != -1) codecCapability->set_channels(codecNumChannels);
+    codecCapability->set_mime_type(codecMimeType);
+    codecList.push_back(codecCapability);
+  }
+  transceiver->SetCodecPreferences(codecList);
+  result_ptr->Success();
+}
+
 void FlutterPeerConnection::GetSenders(
     RTCPeerConnection* pc, std::unique_ptr<MethodResultProxy> result) {
   std::shared_ptr<MethodResultProxy> result_ptr(result.release());
@@ -732,7 +750,7 @@ EncodableMap statsToMap(const scoped_refptr<MediaRTCStats>& stats) {
   report_map[EncodableValue("type")] =
       EncodableValue(stats->type().std_string());
   report_map[EncodableValue("timestamp")] =
-      EncodableValue(double(stats->timestamp_us()));
+      EncodableValue(static_cast<double>(stats->timestamp_us()));
   EncodableMap values;
   auto members = stats->Members();
   for (int i = 0; i < members.size(); i++) {
@@ -782,7 +800,7 @@ void FlutterPeerConnection::GetStats(
     std::unique_ptr<MethodResultProxy> result) {
   std::shared_ptr<MethodResultProxy> result_ptr(result.release());
   scoped_refptr<RTCMediaTrack> track = base_->MediaTracksForId(track_id);
-  if (track != nullptr) {
+  if (track != nullptr && track_id != "") {
     bool found = false;
     auto receivers = pc->receivers();
     for (auto receiver : receivers.std_vector()) {
@@ -885,13 +903,15 @@ void FlutterPeerConnection::AddTrack(
     streamids.push_back(item.c_str());
   }
   if (0 == kind.compare("audio")) {
-    auto sender = pc->AddTrack((RTCAudioTrack*)track.get(), streamids);
+    auto sender =
+        pc->AddTrack(reinterpret_cast<RTCVideoTrack*>(track.get()), streamids);
     if (sender.get() != nullptr) {
       result_ptr->Success(EncodableValue(rtpSenderToMap(sender)));
       return;
     }
   } else if (0 == kind.compare("video")) {
-    auto sender = pc->AddTrack((RTCVideoTrack*)track.get(), streamids);
+    auto sender =
+        pc->AddTrack(reinterpret_cast<RTCVideoTrack*>(track.get()), streamids);
     if (sender.get() != nullptr) {
       result_ptr->Success(EncodableValue(rtpSenderToMap(sender)));
       return;
diff --git a/packages/flutter_webrtc/tizen/src/flutter_video_renderer.cc b/packages/flutter_webrtc/tizen/src/flutter_video_renderer.cc
index 0f860d5db..f9c0c2271 100644
--- a/packages/flutter_webrtc/tizen/src/flutter_video_renderer.cc
+++ b/packages/flutter_webrtc/tizen/src/flutter_video_renderer.cc
@@ -38,8 +38,8 @@ const FlutterDesktopPixelBuffer* FlutterVideoRenderer::CopyPixelBuffer(
     }
 
     frame_->ConvertToARGB(RTCVideoFrame::Type::kABGR, rgb_buffer_.get(), 0,
-                          (int)pixel_buffer_->width,
-                          (int)pixel_buffer_->height);
+                          static_cast<int>(pixel_buffer_->width),
+                          static_cast<int>(pixel_buffer_->height));
 
     pixel_buffer_->buffer = rgb_buffer_.get();
     mutex_.unlock();
@@ -158,4 +158,4 @@ void FlutterVideoRendererManager::VideoRendererDispose(
                 "VideoRendererDispose() texture not found!");
 }
 
-}  // namespace flutter_webrtc_plugin
\ No newline at end of file
+}  // namespace flutter_webrtc_plugin
diff --git a/packages/flutter_webrtc/tizen/src/flutter_webrtc.cc b/packages/flutter_webrtc/tizen/src/flutter_webrtc.cc
index 234614494..56ffa314f 100644
--- a/packages/flutter_webrtc/tizen/src/flutter_webrtc.cc
+++ b/packages/flutter_webrtc/tizen/src/flutter_webrtc.cc
@@ -373,12 +373,9 @@ void FlutterWebRTC::HandleMethodCall(
     const std::string track_id = findString(params, "trackId");
     const EncodableValue enable = findEncodableValue(params, "enabled");
     RTCMediaTrack* track = MediaTrackForId(track_id);
-    if (nullptr == track) {
-      result->Error("mediaStreamTrackSetEnableFailed",
-                    "mediaStreamTrackSetEnable() track is null");
-      return;
+    if (track != nullptr) {
+      track->set_enabled(GetValue<bool>(enable));
     }
-    track->set_enabled(GetValue<bool>(enable));
     result->Success();
   } else if (method_call.method_name().compare("trackDispose") == 0) {
     if (!method_call.arguments()) {
@@ -536,7 +533,7 @@ void FlutterWebRTC::HandleMethodCall(
       if (renderer->CheckMediaStream(streamId) && 0 == kind.compare("video")) {
         renderer->SetVideoTrack(static_cast<RTCVideoTrack*>(track.get()));
       }
-    };
+    }
   } else if (method_call.method_name().compare("mediaStreamRemoveTrack") == 0) {
     if (!method_call.arguments()) {
       result->Error("Bad Arguments", "Null constraints arguments received");
@@ -569,7 +566,7 @@ void FlutterWebRTC::HandleMethodCall(
       if (renderer->CheckVideoTrack(streamId)) {
         renderer->SetVideoTrack(nullptr);
       }
-    };
+    }
   } else if (method_call.method_name().compare("addTrack") == 0) {
     if (!method_call.arguments()) {
       result->Error("Bad Arguments", "Null constraints arguments received");
@@ -592,7 +589,7 @@ void FlutterWebRTC::HandleMethodCall(
     if (track == nullptr) {
       result->Error("AddTrack", "AddTrack() track is null");
       return;
-    };
+    }
     std::list<std::string> listId;
     for (EncodableValue value : streamIds) {
       listId.push_back(GetValue<std::string>(value));
@@ -688,32 +685,6 @@ void FlutterWebRTC::HandleMethodCall(
     }
 
     GetSenders(pc, std::move(result));
-  } else if (method_call.method_name().compare("rtpSenderDispose") == 0) {
-    if (!method_call.arguments()) {
-      result->Error("Bad Arguments", "Null constraints arguments received");
-      return;
-    }
-    const EncodableMap params =
-        GetValue<EncodableMap>(*method_call.arguments());
-    const std::string peerConnectionId = findString(params, "peerConnectionId");
-
-    RTCPeerConnection* pc = PeerConnectionForId(peerConnectionId);
-    if (pc == nullptr) {
-      result->Error("rtpSenderDispose",
-                    "rtpSenderDispose() peerConnection is null");
-      return;
-    }
-
-    const std::string rtpSenderId = findString(params, "rtpSenderId");
-    if (0 < rtpSenderId.size()) {
-      if (pc == nullptr) {
-        result->Error("rtpSenderDispose",
-                      "rtpSenderDispose() rtpSenderId is null or empty");
-        return;
-      }
-    }
-    RtpSenderDispose(pc, rtpSenderId, std::move(result));
-
   } else if (method_call.method_name().compare("rtpSenderSetTrack") == 0) {
     if (!method_call.arguments()) {
       result->Error("Bad Arguments", "Null constraints arguments received");
@@ -796,7 +767,7 @@ void FlutterWebRTC::HandleMethodCall(
     }
 
     const EncodableMap parameters = findMap(params, "parameters");
-    if (0 < parameters.size()) {
+    if (0 == parameters.size()) {
       result->Error("rtpSenderSetParameters",
                     "rtpSenderSetParameters() parameters is null or empty");
       return;
@@ -947,7 +918,8 @@ void FlutterWebRTC::HandleMethodCall(
       result->Error("captureFrame", "captureFrame() track not is video track");
       return;
     }
-    CaptureFrame((RTCVideoTrack*)track, path, std::move(result));
+    CaptureFrame(reinterpret_cast<RTCVideoTrack*>(track), path,
+                 std::move(result));
 
   } else if (method_call.method_name().compare("createLocalMediaStream") == 0) {
     CreateLocalMediaStream(std::move(result));
@@ -1007,6 +979,112 @@ void FlutterWebRTC::HandleMethodCall(
     dtmfSender->InsertDtmf(tone, duration, gap);
 
     result->Success();
+  } else if (method_call.method_name().compare("getRtpSenderCapabilities") ==
+             0) {
+    if (!method_call.arguments()) {
+      result->Error("Bad Arguments", "Null arguments received");
+      return;
+    }
+    const EncodableMap params =
+        GetValue<EncodableMap>(*method_call.arguments());
+
+    RTCMediaType mediaType = RTCMediaType::AUDIO;
+    const std::string kind = findString(params, "kind");
+    if (0 == kind.compare("video")) {
+      mediaType = RTCMediaType::VIDEO;
+    } else if (0 == kind.compare("audio")) {
+      mediaType = RTCMediaType::AUDIO;
+    } else {
+      result->Error("getRtpSenderCapabilities",
+                    "getRtpSenderCapabilities() kind is null or empty");
+      return;
+    }
+    auto capabilities = factory_->GetRtpSenderCapabilities(mediaType);
+    EncodableMap map;
+    EncodableList codecsList;
+    for (auto codec : capabilities->codecs().std_vector()) {
+      EncodableMap codecMap;
+      codecMap[EncodableValue("mimeType")] =
+          EncodableValue(codec->mime_type().std_string());
+      codecMap[EncodableValue("clockRate")] =
+          EncodableValue(codec->clock_rate());
+      codecMap[EncodableValue("channels")] = EncodableValue(codec->channels());
+      codecMap[EncodableValue("sdpFmtpLine")] =
+          EncodableValue(codec->sdp_fmtp_line().std_string());
+      codecsList.push_back(EncodableValue(codecMap));
+    }
+    map[EncodableValue("codecs")] = EncodableValue(codecsList);
+    map[EncodableValue("headerExtensions")] = EncodableValue(EncodableList());
+    map[EncodableValue("fecMechanisms")] = EncodableValue(EncodableList());
+
+    result->Success(EncodableValue(map));
+  } else if (method_call.method_name().compare("getRtpReceiverCapabilities") ==
+             0) {
+    const EncodableMap params =
+        GetValue<EncodableMap>(*method_call.arguments());
+
+    RTCMediaType mediaType = RTCMediaType::AUDIO;
+    const std::string kind = findString(params, "kind");
+    if (0 == kind.compare("video")) {
+      mediaType = RTCMediaType::VIDEO;
+    } else if (0 == kind.compare("audio")) {
+      mediaType = RTCMediaType::AUDIO;
+    } else {
+      result->Error("getRtpSenderCapabilities",
+                    "getRtpSenderCapabilities() kind is null or empty");
+      return;
+    }
+    auto capabilities = factory_->GetRtpReceiverCapabilities(mediaType);
+    EncodableMap map;
+    EncodableList codecsList;
+    for (auto codec : capabilities->codecs().std_vector()) {
+      EncodableMap codecMap;
+      codecMap[EncodableValue("mimeType")] =
+          EncodableValue(codec->mime_type().std_string());
+      codecMap[EncodableValue("clockRate")] =
+          EncodableValue(codec->clock_rate());
+      codecMap[EncodableValue("channels")] = EncodableValue(codec->channels());
+      codecMap[EncodableValue("sdpFmtpLine")] =
+          EncodableValue(codec->sdp_fmtp_line().std_string());
+      codecsList.push_back(EncodableValue(codecMap));
+    }
+    map[EncodableValue("codecs")] = EncodableValue(codecsList);
+    map[EncodableValue("headerExtensions")] = EncodableValue(EncodableList());
+    map[EncodableValue("fecMechanisms")] = EncodableValue(EncodableList());
+
+    result->Success(EncodableValue(map));
+  } else if (method_call.method_name().compare("setCodecPreferences") == 0) {
+    if (!method_call.arguments()) {
+      result->Error("Bad Arguments", "Null arguments received");
+      return;
+    }
+    const EncodableMap params =
+        GetValue<EncodableMap>(*method_call.arguments());
+    const std::string peerConnectionId = findString(params, "peerConnectionId");
+    RTCPeerConnection* pc = PeerConnectionForId(peerConnectionId);
+    if (pc == nullptr) {
+      result->Error("setCodecPreferences",
+                    "setCodecPreferences() peerConnection is null");
+      return;
+    }
+
+    const std::string rtpTransceiverId = findString(params, "transceiverId");
+    if (0 < rtpTransceiverId.size()) {
+      if (pc == nullptr) {
+        result->Error(
+            "setCodecPreferences",
+            "setCodecPreferences() rtpTransceiverId is null or empty");
+        return;
+      }
+    }
+
+    const EncodableList codecs = findList(params, "codecs");
+    if (codecs == EncodableList()) {
+      result->Error("Bad Arguments", "Codecs is required");
+      return;
+    }
+    RtpTransceiverSetCodecPreferences(pc, rtpTransceiverId, codecs,
+                                      std::move(result));
   } else {
     result->NotImplemented();
   }
diff --git a/packages/flutter_webrtc/tizen/src/flutter_webrtc_base.cc b/packages/flutter_webrtc/tizen/src/flutter_webrtc_base.cc
index 79e7cf0c9..acc23011c 100644
--- a/packages/flutter_webrtc/tizen/src/flutter_webrtc_base.cc
+++ b/packages/flutter_webrtc/tizen/src/flutter_webrtc_base.cc
@@ -194,7 +194,6 @@ bool FlutterWebRTCBase::CreateIceServers(const EncodableList &iceServersArray,
     EncodableMap iceServerMap = GetValue<EncodableMap>(iceServersArray[i]);
 
     if (iceServerMap.find(EncodableValue("username")) != iceServerMap.end()) {
-      ;
       ice_server.username = GetValue<std::string>(
           iceServerMap.find(EncodableValue("username"))->second);
     }
diff --git a/packages/flutter_webrtc/tizen/third_party/libwebrtc/include/rtc_desktop_capturer.h b/packages/flutter_webrtc/tizen/third_party/libwebrtc/include/rtc_desktop_capturer.h
index f7c333698..1453869ec 100644
--- a/packages/flutter_webrtc/tizen/third_party/libwebrtc/include/rtc_desktop_capturer.h
+++ b/packages/flutter_webrtc/tizen/third_party/libwebrtc/include/rtc_desktop_capturer.h
@@ -20,7 +20,8 @@ class RTCDesktopCapturer : public RefCountInterface {
   virtual void DeRegisterDesktopCapturerObserver() = 0;
 
   virtual CaptureState Start(uint32_t fps) = 0;
-
+  virtual CaptureState Start(uint32_t fps, uint32_t x, uint32_t y, uint32_t w,
+                             uint32_t h) = 0;
   virtual void Stop() = 0;
 
   virtual bool IsRunning() = 0;
diff --git a/packages/flutter_webrtc/tizen/third_party/libwebrtc/include/rtc_peerconnection_factory.h b/packages/flutter_webrtc/tizen/third_party/libwebrtc/include/rtc_peerconnection_factory.h
index 8352bcc4a..cb024672c 100644
--- a/packages/flutter_webrtc/tizen/third_party/libwebrtc/include/rtc_peerconnection_factory.h
+++ b/packages/flutter_webrtc/tizen/third_party/libwebrtc/include/rtc_peerconnection_factory.h
@@ -17,6 +17,7 @@ namespace libwebrtc {
 class RTCPeerConnection;
 class RTCAudioDevice;
 class RTCVideoDevice;
+class RTCRtpCapabilities;
 
 class RTCPeerConnectionFactory : public RefCountInterface {
  public:
@@ -56,6 +57,12 @@ class RTCPeerConnectionFactory : public RefCountInterface {
 
   virtual scoped_refptr<RTCMediaStream> CreateStream(
       const string stream_id) = 0;
+
+  virtual scoped_refptr<RTCRtpCapabilities> GetRtpSenderCapabilities(
+      RTCMediaType media_type) = 0;
+
+  virtual scoped_refptr<RTCRtpCapabilities> GetRtpReceiverCapabilities(
+      RTCMediaType media_type) = 0;
 };
 
 }  // namespace libwebrtc
diff --git a/packages/flutter_webrtc/tizen/third_party/libwebrtc/include/rtc_rtp_capabilities.h b/packages/flutter_webrtc/tizen/third_party/libwebrtc/include/rtc_rtp_capabilities.h
new file mode 100644
index 000000000..39b49765f
--- /dev/null
+++ b/packages/flutter_webrtc/tizen/third_party/libwebrtc/include/rtc_rtp_capabilities.h
@@ -0,0 +1,60 @@
+#ifndef LIB_WBBRTC_RTC_RTP_CAPABILITIES_HXX
+#define LIB_WBBRTC_RTC_RTP_CAPABILITIES_HXX
+
+#include "base/refcount.h"
+#include "base/scoped_ref_ptr.h"
+#include "rtc_rtp_parameters.h"
+#include "rtc_types.h"
+
+namespace libwebrtc {
+
+class RTCRtpCodecCapability : public RefCountInterface {
+ public:
+  LIB_WEBRTC_API static scoped_refptr<RTCRtpCodecCapability> Create();
+
+  virtual void set_mime_type(const string& mime_type) = 0;
+  virtual void set_clock_rate(int clock_rate) = 0;
+  virtual void set_channels(int channels) = 0;
+  virtual void set_sdp_fmtp_line(const string& sdp_fmtp_line) = 0;
+
+  virtual string mime_type() const = 0;
+  virtual int clock_rate() const = 0;
+  virtual int channels() const = 0;
+  virtual string sdp_fmtp_line() const = 0;
+
+ protected:
+  virtual ~RTCRtpCodecCapability() {}
+};
+
+class RTCRtpHeaderExtensionCapability : public RefCountInterface {
+ public:
+  virtual const string uri() = 0;
+  virtual void set_uri(const string uri) = 0;
+
+  virtual int preferred_id() = 0;
+  virtual void set_preferred_id(int value) = 0;
+
+  virtual bool preferred_encrypt() = 0;
+  virtual void set_preferred_encrypt(bool value) = 0;
+};
+
+class RTCRtpCapabilities : public RefCountInterface {
+ public:
+  virtual const vector<scoped_refptr<RTCRtpCodecCapability>> codecs() = 0;
+  virtual void set_codecs(
+      const vector<scoped_refptr<RTCRtpCodecCapability>> codecs) = 0;
+
+  virtual const vector<scoped_refptr<RTCRtpHeaderExtensionCapability>>
+  header_extensions() = 0;
+
+  virtual void set_header_extensions(
+      const vector<scoped_refptr<RTCRtpHeaderExtensionCapability>>
+          header_extensions) = 0;
+
+  // virtual const vector<scoped_refptr<RTCFecMechanism>> fec() = 0;
+  // virtual void set_fec(const vector<scoped_refptr<RTCFecMechanism>> fec) = 0;
+};
+
+}  // namespace libwebrtc
+
+#endif  // LIB_WBBRTC_RTC_RTP_CAPABILITIES_HXX
diff --git a/packages/flutter_webrtc/tizen/third_party/libwebrtc/include/rtc_rtp_parameters.h b/packages/flutter_webrtc/tizen/third_party/libwebrtc/include/rtc_rtp_parameters.h
index 0dba38cec..422eb3620 100644
--- a/packages/flutter_webrtc/tizen/third_party/libwebrtc/include/rtc_rtp_parameters.h
+++ b/packages/flutter_webrtc/tizen/third_party/libwebrtc/include/rtc_rtp_parameters.h
@@ -1,327 +1,243 @@
-#ifndef LIB_WBBRTC_RTC_RTP_PARAMETERS_HXX
-#define LIB_WBBRTC_RTC_RTP_PARAMETERS_HXX
-
-#include "base/refcount.h"
-#include "base/scoped_ref_ptr.h"
-#include "rtc_types.h"
-
-namespace libwebrtc {
-
-enum class RTCRtpTransceiverDirection {
-  kSendRecv,
-  kSendOnly,
-  kRecvOnly,
-  kInactive,
-  kStopped,
-};
-
-enum class RTCFecMechanism {
-  RED,
-  RED_AND_ULPFEC,
-  FLEXFEC,
-};
-
-enum class RTCRtcpFeedbackType {
-  CCM,
-  LNTF,
-  NACK,
-  REMB,
-  TRANSPORT_CC,
-};
-
-enum class RTCRtcpFeedbackMessageType {
-  GENERIC_NACK,
-  PLI,
-  FIR,
-};
-
-enum class RTCDtxStatus {
-  DISABLED,
-  ENABLED,
-};
-
-enum class RTCDegradationPreference {
-  DISABLED,
-  MAINTAIN_FRAMERATE,
-  MAINTAIN_RESOLUTION,
-  BALANCED,
-};
-
-class RTCRtcpFeedback : public RefCountInterface {
-  virtual RTCRtcpFeedbackType type() = 0;
-  virtual void set_type(RTCRtcpFeedbackType value) = 0;
-
-  virtual RTCRtcpFeedbackMessageType message_type() = 0;
-  virtual void set_message_type(RTCRtcpFeedbackMessageType value) = 0;
-
-  virtual bool operator==(scoped_refptr<RTCRtcpFeedback> o) = 0;
-  virtual bool operator!=(scoped_refptr<RTCRtcpFeedback> o) = 0;
-};
-
-/* class RTCRtpCodecCapability : public RefCountInterface {
-  virtual const string mine_type() const = 0;
-
-  virtual const string name() = 0;
-
-  virtual void set_name(const string name) = 0;
-
-  virtual RTCMediaType kind() = 0;
-  virtual void set_kind(RTCMediaType value) = 0;
-
-  virtual int clock_rate() = 0;
-  virtual void set_clock_rate(int value) = 0;
-
-  virtual int preferred_payload_type() = 0;
-  virtual void set_preferred_payload_type(int value) = 0;
-
-  virtual int max_ptime() = 0;
-  virtual void set_max_ptime(int value) = 0;
-
-  virtual int ptime() = 0;
-  virtual void set_ptime(int value) = 0;
-
-  virtual int num_channels() = 0;
-  virtual void set_num_channels(int value) = 0;
-
-  virtual vector<scoped_refptr<RTCRtcpFeedback>> rtcp_feedback() = 0;
-  virtual void set_rtcp_feedback(vector<scoped_refptr<RTCRtcpFeedback>>
-rtcp_feecbacks) = 0;
-
-  virtual const map<string,string> parameters() = 0;
-  virtual void set_parameters(const map<string, string> parameters) = 0;
-
-  virtual const map<string, string> ptions() = 0;
-  virtual void set_options(map<string, string> options) = 0;
-
-  virtual int max_temporal_layer_extensions() = 0;
-  virtual void set_max_temporal_layer_extensions(int value) = 0;
-
-  virtual int max_spatial_layer_extensions() = 0;
-  virtual void set_max_spatial_layer_extensions(int value) = 0;
-
-  virtual bool svc_multi_stream_support() = 0;
-  virtual void set_svc_multi_stream_support(bool value) = 0;
-
-  virtual bool operator==(scoped_refptr<RTCRtpCodecCapability> o) const = 0;
-  virtual bool operator!=(scoped_refptr<RTCRtpCodecCapability> o) const = 0;
-};*/
-
-class RTCRtpHeaderExtensionCapability : public RefCountInterface {
-  virtual const string uri() = 0;
-  virtual void set_uri(const string uri) = 0;
-
-  virtual int preferred_id() = 0;
-  virtual void set_preferred_id(int value) = 0;
-
-  virtual bool preferred_encrypt() = 0;
-  virtual void set_preferred_encrypt(bool value) = 0;
-
-  virtual RTCRtpTransceiverDirection direction() = 0;
-  virtual void set_direction(RTCRtpTransceiverDirection value) = 0;
-
-  virtual bool operator==(
-      scoped_refptr<RTCRtpHeaderExtensionCapability> o) const = 0;
-  virtual bool operator!=(
-      scoped_refptr<RTCRtpHeaderExtensionCapability> o) const = 0;
-};
-
-class RTCRtpExtension : public RefCountInterface {
- public:
-  enum RTCFilter {
-    kDiscardEncryptedExtension,
-    kPreferEncryptedExtension,
-    kRequireEncryptedExtension,
-  };
-
-  virtual const string ToString() const = 0;
-  virtual bool operator==(scoped_refptr<RTCRtpExtension> o) const = 0;
-
-  virtual const string uri() = 0;
-  virtual void set_uri(const string uri) = 0;
-
-  virtual int id() = 0;
-  virtual void set_id(int value) = 0;
-
-  virtual bool encrypt() = 0;
-  virtual void set_encrypt(bool value) = 0;
-};
-
-class RtpFecParameters : public RefCountInterface {
-  virtual uint32_t ssrc() = 0;
-  virtual void set_ssrc(uint32_t value) = 0;
-
-  virtual RTCFecMechanism mechanism() = 0;
-  virtual void set_mechanism(RTCFecMechanism value) = 0;
-
-  virtual bool operator==(const RtpFecParameters& o) const = 0;
-  virtual bool operator!=(const RtpFecParameters& o) const = 0;
-};
-
-class RTCRtpRtxParameters : public RefCountInterface {
-  virtual uint32_t ssrc() = 0;
-  virtual void set_ssrc(uint32_t value) = 0;
-
-  virtual bool operator==(scoped_refptr<RTCRtpRtxParameters> o) const = 0;
-
-  virtual bool operator!=(scoped_refptr<RTCRtpRtxParameters> o) const = 0;
-};
-
-class RTCRtpCodecParameters : public RefCountInterface {
- public:
-  virtual const string mime_type() const = 0;
-
-  virtual const string name() = 0;
-  virtual void set_name(const string name) = 0;
-
-  virtual RTCMediaType kind() = 0;
-  virtual void set_kind(RTCMediaType value) = 0;
-
-  virtual int payload_type() = 0;
-  virtual void set_payload_type(int value) = 0;
-
-  virtual int clock_rate() = 0;
-  virtual void set_clock_rate(int value) = 0;
-
-  virtual int num_channels() = 0;
-  virtual void set_num_channels(int value) = 0;
-
-  virtual int max_ptime() = 0;
-  virtual void set_max_ptime(int value) = 0;
-
-  virtual int ptime() = 0;
-  virtual void set_ptime(int value) = 0;
-
-  virtual const vector<scoped_refptr<RTCRtcpFeedback>> rtcp_feedback() = 0;
-  virtual void set_rtcp_feedback(
-      const vector<scoped_refptr<RTCRtcpFeedback>> feecbacks) = 0;
-
-  virtual const vector<std::pair<string, string>> parameters() = 0;
-  virtual void set_parameters(const map<string, string> parameters) = 0;
-
-  virtual bool operator==(scoped_refptr<RTCRtpCodecParameters> o) = 0;
-  virtual bool operator!=(scoped_refptr<RTCRtpCodecParameters> o) = 0;
-};
-
-/*
-class RTCRtpCapabilities : public RefCountInterface {
-  virtual const vector<scoped_refptr<RTCRtpCodecCapability>> codecs() = 0;
-  virtual void set_codecs(
-      const vector<scoped_refptr<RTCRtpCodecCapability>> codecs) = 0;
-
-  virtual const vector<scoped_refptr<RTCRtpHeaderExtensionCapability>>
-  header_extensions() = 0;
-
-  virtual void set_header_extensions(
-      const vector<scoped_refptr<RTCRtpHeaderExtensionCapability>>
-          header_extensions) = 0;
-
-  virtual const vector<scoped_refptr<RTCFecMechanism>> fec() = 0;
-  virtual void set_fec(const vector<scoped_refptr<RTCFecMechanism>> fec) = 0;
-
-  virtual bool operator==(scoped_refptr<RTCRtpCapabilities> o) = 0;
-  virtual bool operator!=(scoped_refptr<RTCRtpCapabilities> o) = 0;
-};*/
-
-class RTCRtcpParameters : public RefCountInterface {
- public:
-  virtual uint32_t ssrc() = 0;
-  virtual void set_ssrc(uint32_t value) = 0;
-
-  virtual const string cname() = 0;
-  virtual void set_cname(const string) = 0;
-
-  virtual bool reduced_size() = 0;
-  virtual void set_reduced_size(bool value) = 0;
-
-  virtual bool mux() = 0;
-  virtual void set_mux(bool value) = 0;
-
-  virtual bool operator==(scoped_refptr<RTCRtcpParameters> o) const = 0;
-  virtual bool operator!=(scoped_refptr<RTCRtcpParameters> o) const = 0;
-};
-
-enum class RTCPriority {
-  kVeryLow,
-  kLow,
-  kMedium,
-  kHigh,
-};
-
-class RTCRtpEncodingParameters : public RefCountInterface {
- public:
-  LIB_WEBRTC_API static scoped_refptr<RTCRtpEncodingParameters> Create();
-
-  virtual uint32_t ssrc() = 0;
-  virtual void set_ssrc(uint32_t value) = 0;
-
-  virtual double bitrate_priority() = 0;
-  virtual void set_bitrate_priority(double value) = 0;
-
-  virtual RTCPriority network_priority() = 0;
-  virtual void set_network_priority(RTCPriority value) = 0;
-
-  virtual int max_bitrate_bps() = 0;
-  virtual void set_max_bitrate_bps(int value) = 0;
-
-  virtual int min_bitrate_bps() = 0;
-  virtual void set_min_bitrate_bps(int value) = 0;
-
-  virtual double max_framerate() = 0;
-  virtual void set_max_framerate(double value) = 0;
-
-  virtual int num_temporal_layers() = 0;
-  virtual void set_num_temporal_layers(int value) = 0;
-
-  virtual double scale_resolution_down_by() = 0;
-  virtual void set_scale_resolution_down_by(double value) = 0;
-
-  virtual const string scalability_mode() = 0;
-  virtual void set_scalability_mode(const string mode) = 0;
-
-  virtual bool active() = 0;
-  virtual void set_active(bool value) = 0;
-
-  virtual const string rid() = 0;
-  virtual void set_rid(const string rid) = 0;
-
-  virtual bool adaptive_ptime() = 0;
-  virtual void set_adaptive_ptime(bool value) = 0;
-
-  virtual bool operator==(scoped_refptr<RTCRtpEncodingParameters> o) const = 0;
-  virtual bool operator!=(scoped_refptr<RTCRtpEncodingParameters> o) const = 0;
-};
-
-struct RTCRtpParameters : public RefCountInterface {
- public:
-  // static scoped_refptr<RTCRtpParameters> Create();
-  virtual const string transaction_id() = 0;
-  virtual void set_transaction_id(const string id) = 0;
-
-  virtual const string mid() = 0;
-  virtual void set_mid(const string mid) = 0;
-
-  virtual const vector<scoped_refptr<RTCRtpCodecParameters>> codecs() = 0;
-  virtual void set_codecs(
-      const vector<scoped_refptr<RTCRtpCodecParameters>> codecs) = 0;
-
-  virtual const vector<scoped_refptr<RTCRtpExtension>> header_extensions() = 0;
-  virtual void set_header_extensions(
-      const vector<scoped_refptr<RTCRtpExtension>> header_extensions) = 0;
-
-  virtual const vector<scoped_refptr<RTCRtpEncodingParameters>> encodings() = 0;
-  virtual void set_encodings(
-      const vector<scoped_refptr<RTCRtpEncodingParameters>> encodings) = 0;
-
-  virtual scoped_refptr<RTCRtcpParameters> rtcp_parameters() = 0;
-  virtual void set_rtcp_parameters(
-      scoped_refptr<RTCRtcpParameters> rtcp_parameters) = 0;
-
-  // virtual DegradationPreference GetDegradationPreference() = 0;
-  // virtual void SetDegradationPreference(DegradationPreference value) = 0;
-
-  virtual bool operator==(scoped_refptr<RTCRtpParameters> o) const = 0;
-  virtual bool operator!=(scoped_refptr<RTCRtpParameters> o) const = 0;
-};
-
-}  // namespace libwebrtc
-#endif  // LIB_WBBRTC_RTC_RTP_PARAMETERS_HXX
\ No newline at end of file
+#ifndef LIB_WBBRTC_RTC_RTP_PARAMETERS_HXX
+#define LIB_WBBRTC_RTC_RTP_PARAMETERS_HXX
+
+#include "base/refcount.h"
+#include "base/scoped_ref_ptr.h"
+#include "rtc_types.h"
+
+namespace libwebrtc {
+
+enum class RTCRtpTransceiverDirection {
+  kSendRecv,
+  kSendOnly,
+  kRecvOnly,
+  kInactive,
+  kStopped,
+};
+
+enum class RTCFecMechanism {
+  RED,
+  RED_AND_ULPFEC,
+  FLEXFEC,
+};
+
+enum class RTCRtcpFeedbackType {
+  CCM,
+  LNTF,
+  NACK,
+  REMB,
+  TRANSPORT_CC,
+};
+
+enum class RTCRtcpFeedbackMessageType {
+  GENERIC_NACK,
+  PLI,
+  FIR,
+};
+
+enum class RTCDtxStatus {
+  DISABLED,
+  ENABLED,
+};
+
+enum class RTCDegradationPreference {
+  DISABLED,
+  MAINTAIN_FRAMERATE,
+  MAINTAIN_RESOLUTION,
+  BALANCED,
+};
+
+class RTCRtcpFeedback : public RefCountInterface {
+  virtual RTCRtcpFeedbackType type() = 0;
+  virtual void set_type(RTCRtcpFeedbackType value) = 0;
+
+  virtual RTCRtcpFeedbackMessageType message_type() = 0;
+  virtual void set_message_type(RTCRtcpFeedbackMessageType value) = 0;
+
+  virtual bool operator==(scoped_refptr<RTCRtcpFeedback> o) = 0;
+  virtual bool operator!=(scoped_refptr<RTCRtcpFeedback> o) = 0;
+};
+
+class RTCRtpExtension : public RefCountInterface {
+ public:
+  enum RTCFilter {
+    kDiscardEncryptedExtension,
+    kPreferEncryptedExtension,
+    kRequireEncryptedExtension,
+  };
+
+  virtual const string ToString() const = 0;
+  virtual bool operator==(scoped_refptr<RTCRtpExtension> o) const = 0;
+
+  virtual const string uri() = 0;
+  virtual void set_uri(const string uri) = 0;
+
+  virtual int id() = 0;
+  virtual void set_id(int value) = 0;
+
+  virtual bool encrypt() = 0;
+  virtual void set_encrypt(bool value) = 0;
+};
+
+class RtpFecParameters : public RefCountInterface {
+  virtual uint32_t ssrc() = 0;
+  virtual void set_ssrc(uint32_t value) = 0;
+
+  virtual RTCFecMechanism mechanism() = 0;
+  virtual void set_mechanism(RTCFecMechanism value) = 0;
+
+  virtual bool operator==(const RtpFecParameters& o) const = 0;
+  virtual bool operator!=(const RtpFecParameters& o) const = 0;
+};
+
+class RTCRtpRtxParameters : public RefCountInterface {
+  virtual uint32_t ssrc() = 0;
+  virtual void set_ssrc(uint32_t value) = 0;
+
+  virtual bool operator==(scoped_refptr<RTCRtpRtxParameters> o) const = 0;
+
+  virtual bool operator!=(scoped_refptr<RTCRtpRtxParameters> o) const = 0;
+};
+
+class RTCRtpCodecParameters : public RefCountInterface {
+ public:
+  virtual const string mime_type() const = 0;
+
+  virtual const string name() = 0;
+  virtual void set_name(const string name) = 0;
+
+  virtual RTCMediaType kind() = 0;
+  virtual void set_kind(RTCMediaType value) = 0;
+
+  virtual int payload_type() = 0;
+  virtual void set_payload_type(int value) = 0;
+
+  virtual int clock_rate() = 0;
+  virtual void set_clock_rate(int value) = 0;
+
+  virtual int num_channels() = 0;
+  virtual void set_num_channels(int value) = 0;
+
+  virtual int max_ptime() = 0;
+  virtual void set_max_ptime(int value) = 0;
+
+  virtual int ptime() = 0;
+  virtual void set_ptime(int value) = 0;
+
+  virtual const vector<scoped_refptr<RTCRtcpFeedback>> rtcp_feedback() = 0;
+  virtual void set_rtcp_feedback(
+      const vector<scoped_refptr<RTCRtcpFeedback>> feecbacks) = 0;
+
+  virtual const vector<std::pair<string, string>> parameters() = 0;
+  virtual void set_parameters(const map<string, string> parameters) = 0;
+
+  virtual bool operator==(scoped_refptr<RTCRtpCodecParameters> o) = 0;
+  virtual bool operator!=(scoped_refptr<RTCRtpCodecParameters> o) = 0;
+
+ protected:
+  virtual ~RTCRtpCodecParameters() {}
+};
+
+class RTCRtcpParameters : public RefCountInterface {
+ public:
+  virtual uint32_t ssrc() = 0;
+  virtual void set_ssrc(uint32_t value) = 0;
+
+  virtual const string cname() = 0;
+  virtual void set_cname(const string) = 0;
+
+  virtual bool reduced_size() = 0;
+  virtual void set_reduced_size(bool value) = 0;
+
+  virtual bool mux() = 0;
+  virtual void set_mux(bool value) = 0;
+
+  virtual bool operator==(scoped_refptr<RTCRtcpParameters> o) const = 0;
+  virtual bool operator!=(scoped_refptr<RTCRtcpParameters> o) const = 0;
+};
+
+enum class RTCPriority {
+  kVeryLow,
+  kLow,
+  kMedium,
+  kHigh,
+};
+
+class RTCRtpEncodingParameters : public RefCountInterface {
+ public:
+  LIB_WEBRTC_API static scoped_refptr<RTCRtpEncodingParameters> Create();
+
+  virtual uint32_t ssrc() = 0;
+  virtual void set_ssrc(uint32_t value) = 0;
+
+  virtual double bitrate_priority() = 0;
+  virtual void set_bitrate_priority(double value) = 0;
+
+  virtual RTCPriority network_priority() = 0;
+  virtual void set_network_priority(RTCPriority value) = 0;
+
+  virtual int max_bitrate_bps() = 0;
+  virtual void set_max_bitrate_bps(int value) = 0;
+
+  virtual int min_bitrate_bps() = 0;
+  virtual void set_min_bitrate_bps(int value) = 0;
+
+  virtual double max_framerate() = 0;
+  virtual void set_max_framerate(double value) = 0;
+
+  virtual int num_temporal_layers() = 0;
+  virtual void set_num_temporal_layers(int value) = 0;
+
+  virtual double scale_resolution_down_by() = 0;
+  virtual void set_scale_resolution_down_by(double value) = 0;
+
+  virtual const string scalability_mode() = 0;
+  virtual void set_scalability_mode(const string mode) = 0;
+
+  virtual bool active() = 0;
+  virtual void set_active(bool value) = 0;
+
+  virtual const string rid() = 0;
+  virtual void set_rid(const string rid) = 0;
+
+  virtual bool adaptive_ptime() = 0;
+  virtual void set_adaptive_ptime(bool value) = 0;
+
+  virtual bool operator==(scoped_refptr<RTCRtpEncodingParameters> o) const = 0;
+  virtual bool operator!=(scoped_refptr<RTCRtpEncodingParameters> o) const = 0;
+};
+
+struct RTCRtpParameters : public RefCountInterface {
+ public:
+  // static scoped_refptr<RTCRtpParameters> Create();
+  virtual const string transaction_id() = 0;
+  virtual void set_transaction_id(const string id) = 0;
+
+  virtual const string mid() = 0;
+  virtual void set_mid(const string mid) = 0;
+
+  virtual const vector<scoped_refptr<RTCRtpCodecParameters>> codecs() = 0;
+  virtual void set_codecs(
+      const vector<scoped_refptr<RTCRtpCodecParameters>> codecs) = 0;
+
+  virtual const vector<scoped_refptr<RTCRtpExtension>> header_extensions() = 0;
+  virtual void set_header_extensions(
+      const vector<scoped_refptr<RTCRtpExtension>> header_extensions) = 0;
+
+  virtual const vector<scoped_refptr<RTCRtpEncodingParameters>> encodings() = 0;
+  virtual void set_encodings(
+      const vector<scoped_refptr<RTCRtpEncodingParameters>> encodings) = 0;
+
+  virtual scoped_refptr<RTCRtcpParameters> rtcp_parameters() = 0;
+  virtual void set_rtcp_parameters(
+      scoped_refptr<RTCRtcpParameters> rtcp_parameters) = 0;
+
+  // virtual DegradationPreference GetDegradationPreference() = 0;
+  // virtual void SetDegradationPreference(DegradationPreference value) = 0;
+
+  virtual bool operator==(scoped_refptr<RTCRtpParameters> o) const = 0;
+  virtual bool operator!=(scoped_refptr<RTCRtpParameters> o) const = 0;
+};
+
+}  // namespace libwebrtc
+#endif  // LIB_WBBRTC_RTC_RTP_PARAMETERS_HXX
diff --git a/packages/flutter_webrtc/tizen/third_party/libwebrtc/include/rtc_rtp_transceiver.h b/packages/flutter_webrtc/tizen/third_party/libwebrtc/include/rtc_rtp_transceiver.h
index c68561cc9..2bfc017d3 100644
--- a/packages/flutter_webrtc/tizen/third_party/libwebrtc/include/rtc_rtp_transceiver.h
+++ b/packages/flutter_webrtc/tizen/third_party/libwebrtc/include/rtc_rtp_transceiver.h
@@ -2,6 +2,7 @@
 #define LIB_WEBRTC_RTC_RTP_TRANSCEIVER_HXX
 
 #include "base/refcount.h"
+#include "rtc_rtp_capabilities.h"
 #include "rtc_rtp_parameters.h"
 #include "rtc_rtp_receiver.h"
 #include "rtc_rtp_sender.h"
@@ -54,19 +55,8 @@ class RTCRtpTransceiver : public RefCountInterface {
 
   virtual void StopInternal() = 0;
 
-  // virtual string set_codec_preferences(vector<RTCRtpCodecCapability> codecs)
-  // = 0;
-
-  // virtual vector<RTCRtpCodecCapability> codec_preferences() const = 0;
-
-  // virtual vector<RTCRtpHeaderExtensionCapability> HeaderExtensionsToOffer()
-  // const = 0;
-
-  // virtual std::vector<RTCRtpHeaderExtensionCapability>
-  // HeaderExtensionsNegotiated() const = 0;
-
-  // virtual webrtc::RTCError SetOfferedRtpHeaderExtensions(vector<const
-  // RTCRtpHeaderExtensionCapability> header_extensions_to_offer);
+  virtual void SetCodecPreferences(
+      vector<scoped_refptr<RTCRtpCodecCapability>> codecs) = 0;
 };
 
 }  // namespace libwebrtc