diff --git a/adapter/ohos/capability/clipboard/clipboard_impl.cpp b/adapter/ohos/capability/clipboard/clipboard_impl.cpp
index 7e0861a4c09bef8acad76d93713be748808368e2..1d37c5b1a6da6721bc1a6ea1ad636853c6b03d96 100644
--- a/adapter/ohos/capability/clipboard/clipboard_impl.cpp
+++ b/adapter/ohos/capability/clipboard/clipboard_impl.cpp
@@ -451,6 +451,45 @@ void ClipboardImpl::GetDataAsync(const std::function<void(const std::string&, bo
         TaskExecutor::TaskType::PLATFORM, "ArkUIClipboardGetDataAsync");
 }
 
+void ClipboardImpl::GetSpanStringData(const std::function<void(std::vector<uint8_t>&)>& callback, bool syncMode)
+{
+#ifdef SYSTEM_CLIPBOARD_SUPPORTED
+    if (!taskExecutor_ || !callback) {
+        return;
+    }
+
+    GetSpanStringDataHelper(callback, syncMode);
+#endif
+}
+
+void ClipboardImpl::GetSpanStringDataHelper(const std::function<void(std::vector<uint8_t>&)>& callback, bool syncMode)
+{
+    auto task = [callback, weakExecutor = WeakClaim(RawPtr(taskExecutor_))]() {
+        auto taskExecutor = weakExecutor.Upgrade();
+        CHECK_NULL_VOID(taskExecutor);
+        auto hasData = OHOS::MiscServices::PasteboardClient::GetInstance()->HasPasteData();
+        CHECK_NULL_VOID(hasData);
+        OHOS::MiscServices::PasteData pasteData;
+        auto getDataRes = OHOS::MiscServices::PasteboardClient::GetInstance()->GetPasteData(pasteData);
+        CHECK_NULL_VOID(getDataRes);
+
+        for (const auto& pasteDataRecord : pasteData.AllRecords()) {
+            if (pasteDataRecord == nullptr || pasteDataRecord->GetCustomData() == nullptr) {
+                continue;
+            }
+            auto itemData = pasteDataRecord->GetCustomData()->GetItemData();
+            if (itemData.find(SPAN_STRING_TAG) != itemData.end()) {
+                callback(itemData[SPAN_STRING_TAG]);
+            }
+        }
+    };
+    if (syncMode) {
+        taskExecutor_->PostSyncTask(task, TaskExecutor::TaskType::PLATFORM, "ArkUIClipboardGetSpanStringDataSync");
+    } else {
+        taskExecutor_->PostTask(task, TaskExecutor::TaskType::PLATFORM, "ArkUIClipboardGetSpanStringDataAsync");
+    }
+}
+
 void ClipboardImpl::GetPixelMapDataSync(const std::function<void(const RefPtr<PixelMap>&)>& callback)
 {
     RefPtr<PixelMap> pixmap;
diff --git a/adapter/ohos/capability/clipboard/clipboard_impl.h b/adapter/ohos/capability/clipboard/clipboard_impl.h
index a0dad361d8e33fe833e31742789446eaddb18d2f..4fe05813904dd9cfde5cca9b93f41a4512e7a486 100644
--- a/adapter/ohos/capability/clipboard/clipboard_impl.h
+++ b/adapter/ohos/capability/clipboard/clipboard_impl.h
@@ -47,6 +47,7 @@ public:
     RefPtr<PasteDataMix> CreatePasteDataMix() override;
     void HasData(const std::function<void(bool hasData)>& callback) override;
     void Clear() override;
+    void GetSpanStringData(const std::function<void(std::vector<uint8_t>&)>& callback, bool syncMode = false) override;
 
 #ifdef SYSTEM_CLIPBOARD_SUPPORTED
 private:
@@ -62,6 +63,7 @@ private:
         std::string& resText);
     void GetPixelMapDataSync(const std::function<void(const RefPtr<PixelMap>&)>& callback);
     void GetPixelMapDataAsync(const std::function<void(const RefPtr<PixelMap>&)>& callback);
+    void GetSpanStringDataHelper(const std::function<void(std::vector<uint8_t>&)>& callback, bool syncMode);
 #endif
 };
 
diff --git a/adapter/preview/entrance/clipboard/clipboard_impl.cpp b/adapter/preview/entrance/clipboard/clipboard_impl.cpp
index d746ffc6dd0137e537837bc5b34a8dca8bfbd136..43f88a8a0a396651fa38ffc5f6c42b7d6c689b71 100644
--- a/adapter/preview/entrance/clipboard/clipboard_impl.cpp
+++ b/adapter/preview/entrance/clipboard/clipboard_impl.cpp
@@ -29,6 +29,7 @@ void ClipboardImpl::GetData(const std::function<void(const std::string&, bool is
     const std::function<void(const RefPtr<PixelMap>&, bool isLastRecord)>& pixelMapCallback,
     const std::function<void(const std::string&, bool isLastRecord)>& urlCallback, bool syncMode)
 {}
+void ClipboardImpl::GetSpanStringData(const std::function<void(std::vector<uint8_t>&)>& callback, bool syncMode) {}
 
 RefPtr<PasteDataMix> ClipboardImpl::CreatePasteDataMix()
 {
diff --git a/adapter/preview/entrance/clipboard/clipboard_impl.h b/adapter/preview/entrance/clipboard/clipboard_impl.h
index 3e4e5029d238324ce4856d4bab4db756c243ec16..5ee320a9b89b0e1737b201f32a8064c7505319c5 100644
--- a/adapter/preview/entrance/clipboard/clipboard_impl.h
+++ b/adapter/preview/entrance/clipboard/clipboard_impl.h
@@ -52,6 +52,7 @@ public:
     void GetData(const std::function<void(const std::string&, bool isLastRecord)>& textCallback,
         const std::function<void(const RefPtr<PixelMap>&, bool isLastRecord)>& pixelMapCallback,
         const std::function<void(const std::string&, bool isLastRecord)>& urlCallback, bool syncMode = false) override;
+    void GetSpanStringData(const std::function<void(std::vector<uint8_t>&)>& callback, bool syncMode = false) override;
     RefPtr<PasteDataMix> CreatePasteDataMix() override;
 
 private:
diff --git a/frameworks/core/common/clipboard/clipboard.h b/frameworks/core/common/clipboard/clipboard.h
index 612ec0f787fac3ef4bcf965313a892152d5d5f63..416752e5f124ed38539ac527306a2860bd08e390 100644
--- a/frameworks/core/common/clipboard/clipboard.h
+++ b/frameworks/core/common/clipboard/clipboard.h
@@ -47,6 +47,8 @@ public:
         const std::function<void(const std::string&, bool isLastRecord)>& urlCallback, bool syncMode = false) = 0;
     virtual RefPtr<PasteDataMix> CreatePasteDataMix() = 0;
     virtual void Clear() = 0;
+    virtual void GetSpanStringData(
+        const std::function<void(std::vector<uint8_t>&)>& callback, bool syncMode = false) = 0;
 
 protected:
     explicit Clipboard(const RefPtr<TaskExecutor>& taskExecutor) : taskExecutor_(taskExecutor) {}
diff --git a/frameworks/core/components_ng/pattern/rich_editor/rich_editor_pattern.cpp b/frameworks/core/components_ng/pattern/rich_editor/rich_editor_pattern.cpp
index 3ca306155d2ffa250e3f034563311d1e8212949d..fa361f39863d08c1f3047ad537023cf0f409b3e5 100644
--- a/frameworks/core/components_ng/pattern/rich_editor/rich_editor_pattern.cpp
+++ b/frameworks/core/components_ng/pattern/rich_editor/rich_editor_pattern.cpp
@@ -694,6 +694,7 @@ int32_t RichEditorPattern::AddImageSpan(const ImageSpanOptions& options, bool is
     auto spanItem = imageNode->GetSpanItem();
     // The length of the imageSpan defaults to the length of a character to calculate the position
     spanItem->content = " ";
+    spanItem->SetImageSpanOptions(options);
     AddSpanItem(spanItem, spanIndex);
     SetGestureOptions(options.userGestureOption, spanItem);
     placeholderCount_++;
@@ -2583,11 +2584,6 @@ void RichEditorPattern::HandleDraggableFlag(bool isTouchSelectArea)
 {
     auto gestureHub = GetGestureEventHub();
     CHECK_NULL_VOID(gestureHub);
-    // SpanString do not support drag
-    if (isSpanStringMode_) {
-        gestureHub->SetIsTextDraggable(false);
-        return;
-    }
     if (copyOption_ != CopyOptions::None && isTouchSelectArea) {
         bool isContentDraggalbe = JudgeContentDraggable();
         if (isContentDraggalbe) {
@@ -3112,6 +3108,277 @@ void RichEditorPattern::OnDragEnd(const RefPtr<Ace::DragEvent>& event)
     host->MarkDirtyNode(PROPERTY_UPDATE_MEASURE_SELF);
 }
 
+
+void RichEditorPattern::AddUdmfData(const RefPtr<Ace::DragEvent>& event)
+{
+    RefPtr<UnifiedData> unifiedData = UdmfClient::GetInstance()->CreateUnifiedData();
+    AddSpanStringUdmfRecord(unifiedData);
+    std::list<ResultObject> finalResult;
+    auto type = SelectSpanType::TYPESPAN;
+    for (const auto& resultObj : dragResultObjects_) {
+        if (finalResult.empty() || resultObj.type != SelectSpanType::TYPESPAN || type != SelectSpanType::TYPESPAN) {
+            type = resultObj.type;
+            finalResult.emplace_back(resultObj);
+            if (resultObj.type == SelectSpanType::TYPESPAN) {
+                AddUdmfTxtPreProcessor(resultObj, finalResult.back(), false);
+            }
+        } else {
+            AddUdmfTxtPreProcessor(resultObj, finalResult.back(), true);
+        }
+    }
+    auto resultProcessor = [unifiedData, weak = WeakClaim(this)](const ResultObject& result) {
+        auto pattern = weak.Upgrade();
+        CHECK_NULL_VOID(pattern);
+        if (result.type == SelectSpanType::TYPESPAN) {
+            UdmfClient::GetInstance()->AddPlainTextRecord(unifiedData, result.valueString);
+            return;
+        }
+        if (result.type == SelectSpanType::TYPEIMAGE) {
+            if (result.valuePixelMap) {
+                const uint8_t* pixels = result.valuePixelMap->GetPixels();
+                CHECK_NULL_VOID(pixels);
+                int32_t length = result.valuePixelMap->GetByteCount();
+                std::vector<uint8_t> data(pixels, pixels + length);
+                PixelMapRecordDetails details = { result.valuePixelMap->GetWidth(), result.valuePixelMap->GetHeight(),
+                    result.valuePixelMap->GetPixelFormat(), result.valuePixelMap->GetAlphaType() };
+                UdmfClient::GetInstance()->AddPixelMapRecord(unifiedData, data, details);
+            } else if (result.valueString.size() > 1) {
+                UdmfClient::GetInstance()->AddImageRecord(unifiedData, result.valueString);
+            }
+        }
+    };
+    for (const auto& resultObj : finalResult) {
+        resultProcessor(resultObj);
+    }
+    event->SetData(unifiedData);
+}
+
+void RichEditorPattern::AddSpanStringUdmfRecord(RefPtr<UnifiedData>& unifiedData)
+{
+    auto selectStart = textSelector_.GetTextStart();
+    auto selectEnd = textSelector_.GetTextEnd();
+
+    RefPtr<SpanString> selectInfo;
+    if (isSpanStringMode_) {
+        selectInfo = styledString_->GetSubSpanString(selectStart, selectEnd - selectStart);
+    } else {
+        selectInfo = ToStyledString(selectStart, selectEnd);
+    }
+    CHECK_NULL_VOID(selectInfo);
+    std::vector<uint8_t> arr;
+    selectInfo->EncodeTlv(arr);
+    UdmfClient::GetInstance()->AddSpanStringRecord(unifiedData, arr);
+}
+
+RefPtr<SpanString> RichEditorPattern::ToStyledString(int32_t start, int32_t length)
+{
+    RefPtr<SpanString> spanString;
+    SetSubSpans(spanString, start, length);
+    SetSubMap(spanString);
+    return spanString;
+}
+
+void RichEditorPattern::SetSubSpans(RefPtr<SpanString>& spanString, int32_t start, int32_t length)
+{
+    std::list<RefPtr<SpanItem>> subSpans;
+    auto end = start + length;
+    std::string text;
+    for (const auto& spanItem : spans_) {
+        auto spanEndPos = spanItem->position;
+        auto spanLength = static_cast<int32_t>(StringUtils::ToWstring(spanItem->content).length());
+        auto spanStartPos = spanEndPos - spanLength;
+
+        if (spanEndPos >= start && spanStartPos <= start +length) {
+            int32_t oldStart = spanStartPos;
+            int32_t oldEnd = spanEndPos;
+            auto spanStart = oldStart <= start ? 0 : oldStart - start;
+            auto spanEnd = oldEnd < end ? oldEnd - start : end - start;
+            auto newSpanItem = spanItem->GetSameStyleSpanItem();
+            newSpanItem->interval = {spanStart, spanEnd};
+            newSpanItem->content = StringUtils::ToString(
+                StringUtils::ToWstring(spanItem->content)
+                    .substr(std::max(start - oldStart, 0), std::min(end, oldEnd) - std::max(start, oldStart)));
+            text.append(newSpanItem->content);
+            subSpans.emplace_back(newSpanItem);
+        }
+    }
+    spanString->SetString(text);
+    spanString->SetSpanItems(std::move(subSpans));
+}
+
+void RichEditorPattern::SetSubMap(RefPtr<SpanString>& spanString)
+{
+    auto subSpans = spanString->GetSpanItems();
+    std::unordered_map<SpanType, std::list<RefPtr<SpanBase>>> subMap;
+    for (auto& spanItem : subSpans) {
+        if (!spanItem) {
+            continue;
+        }
+        std::list<RefPtr<SpanBase>> spanBases;
+        spanBases.emplace_back(ToFontSpan(spanItem));
+        spanBases.emplace_back(ToDecorationSpan(spanItem));
+        spanBases.emplace_back(ToBaselineOffsetSpan(spanItem));
+        spanBases.emplace_back(ToLetterSpacingSpan(spanItem));
+        spanBases.emplace_back(ToGestureSpan(spanItem));
+        spanBases.emplace_back(ToImageSpan(spanItem));
+        spanBases.emplace_back(ToParagraphStyleSpan(spanItem));
+        spanBases.emplace_back(ToLineHeightSpan(spanItem));
+        for (auto& spanBase : spanBases) {
+            if (!spanBase) {
+                continue;
+            }
+            if (subMap.find(spanBase->GetSpanType()) == subMap.end()) {
+                subMap[spanBase->GetSpanType()].emplace_back(spanBase);
+            } else {
+                auto spans = subMap[spanBase->GetSpanType()];
+                spans.emplace_back(spanBase);
+                subMap[spanBase->GetSpanType()] = spans;
+            }
+        }
+    }
+    spanString->SetSpanMap(std::move(subMap));
+}
+
+RefPtr<FontSpan> RichEditorPattern::ToFontSpan(RefPtr<SpanItem>& spanItem)
+{
+    CHECK_NULL_RETURN(spanItem && spanItem->fontStyle, nullptr);
+    Font font;
+    font.fontColor = spanItem->fontStyle->GetTextColor();
+    font.fontFamiliesNG = spanItem->fontStyle->GetFontFamily();
+    font.fontSize = spanItem->fontStyle->GetFontSize();
+    font.fontStyle = spanItem->fontStyle->GetItalicFontStyle();
+    font.fontWeight = spanItem->fontStyle->GetFontWeight();
+    return AceType::MakeRefPtr<FontSpan>(font);
+}
+
+RefPtr<DecorationSpan> RichEditorPattern::ToDecorationSpan(RefPtr<SpanItem>& spanItem)
+{
+    CHECK_NULL_RETURN(spanItem && spanItem->fontStyle, nullptr);
+    TextDecoration type;
+    std::optional<Color> color;
+    std::optional<TextDecorationStyle> style;
+    if (spanItem->fontStyle->GetTextDecoration().has_value()) {
+        type = spanItem->fontStyle->GetTextDecoration().value();
+    }
+    color = spanItem->fontStyle->GetTextDecorationColor();
+    style = spanItem->fontStyle->GetTextDecorationStyle();
+    return AceType::MakeRefPtr<DecorationSpan>(type, color, style);
+}
+
+RefPtr<BaselineOffsetSpan> RichEditorPattern::ToBaselineOffsetSpan(RefPtr<SpanItem>& spanItem)
+{
+    CHECK_NULL_RETURN(spanItem && spanItem->textLineStyle, nullptr);
+    Dimension baselineOffset;
+    if (spanItem->textLineStyle->GetBaselineOffset().has_value()) {
+        baselineOffset.SetValue(spanItem->textLineStyle->GetBaselineOffsetValue().ConvertToVp());
+    }
+    return AceType::MakeRefPtr<BaselineOffsetSpan>(baselineOffset);
+}
+
+RefPtr<LetterSpacingSpan> RichEditorPattern::ToLetterSpacingSpan(RefPtr<SpanItem>& spanItem)
+{
+    CHECK_NULL_RETURN(spanItem && spanItem->fontStyle, nullptr);
+    Dimension letterSpacing;
+    if (spanItem->fontStyle->GetLetterSpacing().has_value()) {
+        letterSpacing.SetValue(spanItem->fontStyle->GetLetterSpacingValue().ConvertToVp());
+    }
+    return AceType::MakeRefPtr<LetterSpacingSpan>(letterSpacing);
+}
+
+RefPtr<GestureSpan> RichEditorPattern::ToGestureSpan(RefPtr<SpanItem>& spanItem)
+{
+    CHECK_NULL_RETURN(spanItem, nullptr);
+    GestureStyle gestureInfo;
+    if (spanItem->onClick) {
+        gestureInfo.onClick = spanItem->onClick;
+    }
+    if (spanItem->onLongPress) {
+        gestureInfo.onLongPress = spanItem->onLongPress;
+    }
+    return AceType::MakeRefPtr<GestureSpan>(gestureInfo);
+}
+
+RefPtr<TextShadowSpan> RichEditorPattern::ToTextShadowSpan(RefPtr<SpanItem>& spanItem)
+{
+    CHECK_NULL_RETURN(spanItem && spanItem->fontStyle, nullptr);
+    return AceType::MakeRefPtr<TextShadowSpan>(spanItem->fontStyle->GetTextShadow().value());
+}
+
+RefPtr<ImageSpan> RichEditorPattern::ToImageSpan(RefPtr<SpanItem>& spanItem)
+{
+    CHECK_NULL_RETURN(spanItem, nullptr);
+    auto imageItem = DynamicCast<ImageSpanItem>(spanItem);
+    CHECK_NULL_RETURN(imageItem, nullptr);
+    const auto& options = imageItem->options;
+    return AceType::MakeRefPtr<ImageSpan>(options);
+}
+
+RefPtr<ParagraphStyleSpan> RichEditorPattern::ToParagraphStyleSpan(RefPtr<SpanItem>& spanItem)
+{
+    CHECK_NULL_RETURN(spanItem && spanItem->textLineStyle, nullptr);
+    SpanParagraphStyle paragraphStyle;
+    paragraphStyle.align = spanItem->textLineStyle->GetTextAlign();
+    paragraphStyle.maxLines = spanItem->textLineStyle->GetMaxLines();
+    paragraphStyle.textOverflow = spanItem->textLineStyle->GetTextOverflow();
+    paragraphStyle.leadingMargin = spanItem->textLineStyle->GetLeadingMargin();
+    paragraphStyle.wordBreak = spanItem->textLineStyle->GetWordBreak();
+    paragraphStyle.textIndent = spanItem->textLineStyle->GetTextIndent();
+    return AceType::MakeRefPtr<ParagraphStyleSpan>(paragraphStyle);
+}
+
+RefPtr<LineHeightSpan> RichEditorPattern::ToLineHeightSpan(RefPtr<SpanItem>& spanItem)
+{
+    CHECK_NULL_RETURN(spanItem && spanItem->textLineStyle, nullptr);
+    Dimension lineHeight;
+    if (spanItem->textLineStyle->GetLineHeight().has_value()) {
+        lineHeight.SetValue(spanItem->textLineStyle->GetLineHeightValue().ConvertToVp());
+    }
+    return AceType::MakeRefPtr<LineHeightSpan>(lineHeight);
+}
+
+void RichEditorPattern::AddSpanByPasteData(const RefPtr<SpanString>& spanString)
+{
+    CHECK_NULL_VOID(spanString);
+    if (isSpanStringMode_) {
+        styledString_->InsertSpanString(caretPosition_, spanString);
+        moveLength_ += StringUtils::ToWstring(spanString->GetString()).length();
+    } else {
+        auto spanItems = spanString->GetSpanItems();
+        for (const auto& spanItem : spanItems) {
+            if (!spanItem) {
+                continue;
+            }
+            auto imageSpanItem = DynamicCast<ImageSpanItem>(spanItem);
+            if (imageSpanItem) {
+                AddImageSpan(imageSpanItem->options, true, caretPosition_, true);
+            } else {
+                auto options = GetTextSpanOptions(spanItem);
+                AddTextSpan(options, true, caretPosition_);
+            }
+        }
+    }
+    StartTwinkling();
+    CloseSelectOverlay();
+    auto host = GetHost();
+    CHECK_NULL_VOID(host);
+    host->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
+    host->MarkModifyDone();
+}
+
+TextSpanOptions RichEditorPattern::GetTextSpanOptions(const RefPtr<SpanItem>& spanItem)
+{
+    TextSpanOptions options;
+    CHECK_NULL_RETURN(spanItem, options);
+    options.value = spanItem->content;
+    options.offset = caretPosition_;
+    options.userGestureOption.onClick = spanItem->onClick;
+    options.userGestureOption.onLongPress = spanItem->onLongPress;
+    TextStyle textStyle;
+    UseSelfStyle(spanItem->fontStyle, spanItem->textLineStyle, textStyle);
+    options.style = textStyle;
+    return options;
+}
+
 void RichEditorPattern::ResetDragSpanItems()
 {
     auto host = GetHost();
@@ -5706,8 +5973,36 @@ void RichEditorPattern::CheckEditorTypeChange()
     }
 }
 
+void RichEditorPattern::OnCopyOperationExt(RefPtr<PasteDataMix>& pasteData)
+{
+    auto subSpanString =
+        ToStyledString(textSelector_.GetTextStart(), textSelector_.GetTextEnd() - textSelector_.GetTextStart());
+    std::vector<uint8_t> tlvData;
+    subSpanString->EncodeTlv(tlvData);
+    auto text = subSpanString->GetString();
+    clipboard_->AddSpanStringRecord(pasteData, tlvData);
+}
+
+void RichEditorPattern::HandleOnCopyStyledString()
+{
+    RefPtr<PasteDataMix> pasteData = clipboard_->CreatePasteDataMix();
+    auto subSpanString = styledString_->GetSubSpanString(textSelector_.GetTextStart(),
+        textSelector_.GetTextEnd() - textSelector_.GetTextStart());
+    std::vector<uint8_t> tlvData;
+    subSpanString->EncodeTlv(tlvData);
+    clipboard_->AddSpanStringRecord(pasteData, tlvData);
+    clipboard_->AddTextRecord(pasteData, subSpanString->GetString());
+    clipboard_->SetData(pasteData, copyOption_);
+}
+
 void RichEditorPattern::OnCopyOperation(bool isUsingExternalKeyboard)
 {
+    if (isSpanStringMode_) {
+        HandleOnCopyStyledString();
+        return;
+    }
+    RefPtr<PasteDataMix> pasteData = clipboard_->CreatePasteDataMix();
+    OnCopyOperationExt(pasteData);
     auto selectStart = textSelector_.GetTextStart();
     auto selectEnd = textSelector_.GetTextEnd();
     auto textSelectInfo = GetSpansInfo(selectStart, selectEnd, GetSpansMethod::ONSELECT);
@@ -5716,7 +6011,6 @@ void RichEditorPattern::OnCopyOperation(bool isUsingExternalKeyboard)
     if (copyResultObjects.empty()) {
         return;
     }
-    RefPtr<PasteDataMix> pasteData = clipboard_->CreatePasteDataMix();
     auto resultProcessor = [weak = WeakClaim(this), pasteData, selectStart, selectEnd, clipboard = clipboard_](
                                const ResultObject& result) {
         auto pattern = weak.Upgrade();
@@ -5817,11 +6111,14 @@ void RichEditorPattern::HandleOnPaste()
         return;
     }
     CHECK_NULL_VOID(clipboard_);
-    auto pasteCallback = [weak = WeakClaim(this)](const std::string& data) {
+    auto pasteCallback = [weak = WeakClaim(this)](std::vector<uint8_t>& arr) {
         TAG_LOGI(AceLogTag::ACE_RICH_TEXT, "pasteCallback callback");
+        auto str = SpanString::DecodeTlv(arr);
+        CHECK_NULL_VOID(str);
         auto richEditor = weak.Upgrade();
         CHECK_NULL_VOID(richEditor);
-        if (data.empty()) {
+        auto spanItems = str->GetSpanItems();
+        if (spanItems.empty()) {
             richEditor->ResetSelection();
             richEditor->StartTwinkling();
             richEditor->CloseSelectOverlay();
@@ -5832,10 +6129,9 @@ void RichEditorPattern::HandleOnPaste()
             }
             return;
         }
-        richEditor->AddPasteStr(data);
-        richEditor->ResetAfterPaste();
+        richEditor->AddSpanByPasteData(str);
     };
-    clipboard_->GetData(pasteCallback);
+    clipboard_->GetSpanStringData(pasteCallback);
 }
 
 void RichEditorPattern::SetCaretSpanIndex(int32_t index)
@@ -7452,9 +7748,21 @@ Color RichEditorPattern::GetSelectedBackgroundColor()
     return selectedBackgroundColor;
 }
 
+void RichEditorPattern::HandleOnDragDropStyledString(const RefPtr<OHOS::Ace::DragEvent>& event)
+{
+    CHECK_NULL_VOID(event);
+    auto data = event->GetData();
+    CHECK_NULL_VOID(data);
+    std::string str;
+    auto arr = UdmfClient::GetInstance()->GetSpanStringRecord(data);
+    if (!arr.empty()) {
+        auto spanStr = SpanString::DecodeTlv(arr);
+        AddSpanByPasteData(spanStr);
+    }
+}
+
 void RichEditorPattern::HandleOnDragDrop(const RefPtr<OHOS::Ace::DragEvent>& event)
 {
-    CHECK_NULL_VOID(!isSpanStringMode_);
     auto host = GetHost();
     CHECK_NULL_VOID(host);
     auto eventHub = host->GetEventHub<RichEditorEventHub>();
@@ -7466,27 +7774,7 @@ void RichEditorPattern::HandleOnDragDrop(const RefPtr<OHOS::Ace::DragEvent>& eve
         StartTwinkling();
         return;
     }
-
-    auto data = event->GetData();
-    CHECK_NULL_VOID(data);
-
-    auto records = UdmfClient::GetInstance()->GetPlainTextRecords(data);
-    if (records.empty()) {
-        return;
-    }
-
-    std::string str;
-    for (const auto& record : records) {
-        str += record;
-    }
-
-    if (str.empty()) {
-        TAG_LOGI(AceLogTag::ACE_RICH_TEXT, "text is empty.");
-        return;
-    }
-
-    HandleOnDragDropTextOperation(str, isDragSponsor_);
-
+    HandleOnDragDropStyledString(event);
     if (textSelector_.IsValid()) {
         CloseSelectOverlay();
         ResetSelection();
diff --git a/frameworks/core/components_ng/pattern/rich_editor/rich_editor_pattern.h b/frameworks/core/components_ng/pattern/rich_editor/rich_editor_pattern.h
index d8265599b5c39a07244cb28cd6f68d577a527ae3..8b074b901c6c168abd7bb515dd6c5b94ba6c7130 100644
--- a/frameworks/core/components_ng/pattern/rich_editor/rich_editor_pattern.h
+++ b/frameworks/core/components_ng/pattern/rich_editor/rich_editor_pattern.h
@@ -533,6 +533,7 @@ public:
     bool BetweenSelectedPosition(const Offset& globalOffset) override;
     void HandleSurfaceChanged(int32_t newWidth, int32_t newHeight, int32_t prevWidth, int32_t prevHeight) override;
     void HandleSurfacePositionChanged(int32_t posX, int32_t posY) override;
+    void AddUdmfData(const RefPtr<Ace::DragEvent>& event) override;
     bool RequestCustomKeyboard();
     bool CloseCustomKeyboard();
     const std::string& GetPasteStr() const
@@ -1013,6 +1014,25 @@ private:
     bool CheckTripClickEvent(GestureEvent& info);
     void HandleSelect(GestureEvent& info, int32_t selectStart, int32_t selectEnd);
     void SwitchState();
+    RefPtr<SpanString> ToStyledString(int32_t start, int32_t length);
+    void SetSubSpans(RefPtr<SpanString>& spanString, int32_t start, int32_t length);
+    void SetSubMap(RefPtr<SpanString>& spanString);
+    RefPtr<SpanString> FromStyledString(int32_t start, int32_t length);
+    RefPtr<LineHeightSpan> ToLineHeightSpan(RefPtr<SpanItem>& spanItem);
+    RefPtr<ParagraphStyleSpan> ToParagraphStyleSpan(RefPtr<SpanItem>& spanItem);
+    RefPtr<ImageSpan> ToImageSpan(RefPtr<SpanItem>& spanItem);
+    RefPtr<TextShadowSpan> ToTextShadowSpan(RefPtr<SpanItem>& spanItem);
+    RefPtr<GestureSpan> ToGestureSpan(RefPtr<SpanItem>& spanItem);
+    RefPtr<LetterSpacingSpan> ToLetterSpacingSpan(RefPtr<SpanItem>& spanItem);
+    RefPtr<BaselineOffsetSpan> ToBaselineOffsetSpan(RefPtr<SpanItem>& spanItem);
+    RefPtr<DecorationSpan> ToDecorationSpan(RefPtr<SpanItem>& spanItem);
+    RefPtr<FontSpan> ToFontSpan(RefPtr<SpanItem>& spanItem);
+    void OnCopyOperationExt(RefPtr<PasteDataMix>& pasteData);
+    void AddSpanByPasteData(const RefPtr<SpanString>& spanString);
+    TextSpanOptions GetTextSpanOptions(const RefPtr<SpanItem>& spanItem);
+    void HandleOnCopyStyledString();
+    void HandleOnDragDropStyledString(const RefPtr<OHOS::Ace::DragEvent>& event);
+    void AddSpanStringUdmfRecord(RefPtr<UnifiedData>& unifiedData);
 
 #if defined(ENABLE_STANDARD_INPUT)
     sptr<OHOS::MiscServices::OnTextChangedListener> richEditTextChangeListener_;
diff --git a/frameworks/core/components_ng/pattern/text/span/span_string.cpp b/frameworks/core/components_ng/pattern/text/span/span_string.cpp
index 1afb3dcdca8d2c7acb22ef46ebe489b952ec2880..ebf2d5dcbb8de4fc910659f2fa84c254625a3555 100644
--- a/frameworks/core/components_ng/pattern/text/span/span_string.cpp
+++ b/frameworks/core/components_ng/pattern/text/span/span_string.cpp
@@ -456,6 +456,16 @@ void SpanString::SetString(const std::string& text)
     text_ = text;
 }
 
+void SpanString::SetSpanItems(const std::list<RefPtr<NG::SpanItem>>&& spanItems)
+{
+    spans_ = spanItems;
+}
+
+void SpanString::SetSpanMap(std::unordered_map<SpanType, std::list<RefPtr<SpanBase>>>&& spansMap)
+{
+    spansMap_ = spansMap;
+}
+
 const std::string& SpanString::GetString() const
 {
     return text_;
diff --git a/frameworks/core/components_ng/pattern/text/span/span_string.h b/frameworks/core/components_ng/pattern/text/span/span_string.h
index 57fc95ddc79b403ec914be243575ee55242a114e..2b0525a2859c7a192d684205df531a02e2d3f191 100644
--- a/frameworks/core/components_ng/pattern/text/span/span_string.h
+++ b/frameworks/core/components_ng/pattern/text/span/span_string.h
@@ -44,6 +44,8 @@ public:
     std::wstring GetWideString();
     int32_t GetLength() const;
     void SetString(const std::string& text);
+    void SetSpanItems(const std::list<RefPtr<NG::SpanItem>>&& spanItems);
+    void SetSpanMap(std::unordered_map<SpanType, std::list<RefPtr<SpanBase>>>&& spansMap);
     const std::unordered_map<SpanType, std::list<RefPtr<SpanBase>>>& GetSpansMap() const;
     bool IsEqualToSpanString(const RefPtr<SpanString>& other) const;
     RefPtr<SpanString> GetSubSpanString(int32_t start, int32_t length) const;
diff --git a/frameworks/core/components_ng/pattern/text/text_pattern.h b/frameworks/core/components_ng/pattern/text/text_pattern.h
index 20f0b8538597d6b16a0661630461fdc6a17538f8..6c8e0ce9d339e5b2a61dcea1b665c9e58c3efb06 100644
--- a/frameworks/core/components_ng/pattern/text/text_pattern.h
+++ b/frameworks/core/components_ng/pattern/text/text_pattern.h
@@ -332,7 +332,7 @@ public:
     void OnDragEndNoChild(const RefPtr<Ace::DragEvent>& event);
     void CloseOperate();
     void OnDragMove(const RefPtr<Ace::DragEvent>& event);
-    void AddUdmfData(const RefPtr<Ace::DragEvent>& event);
+    virtual void AddUdmfData(const RefPtr<Ace::DragEvent>& event);
 
     std::string GetSelectedSpanText(std::wstring value, int32_t start, int32_t end) const;
     TextStyleResult GetTextStyleObject(const RefPtr<SpanNode>& node);
@@ -666,6 +666,7 @@ protected:
     double GetTextHeight(int32_t index, bool isNextLine);
     int32_t GetTextLength();
     bool IsSelectableAndCopy();
+    void AddUdmfTxtPreProcessor(const ResultObject src, ResultObject& result, bool isAppend);
 
     virtual bool CanStartAITask()
     {
@@ -779,7 +780,6 @@ private:
         return lastDragTool_;
     }
 
-    void AddUdmfTxtPreProcessor(const ResultObject src, ResultObject& result, bool isAppend);
     void ProcessOverlayAfterLayout();
     Offset ConvertGlobalToLocalOffset(const Offset& globalOffset);
     Offset ConvertLocalOffsetToParagraphOffset(const Offset& offset);
diff --git a/test/mock/core/common/mock_clipboard.cpp b/test/mock/core/common/mock_clipboard.cpp
index 060fae4bdcecfd524071d895f1b37b6913166b6c..5e4f088a4b5eaf6f36afac0805f02e4c8d4e17fd 100644
--- a/test/mock/core/common/mock_clipboard.cpp
+++ b/test/mock/core/common/mock_clipboard.cpp
@@ -74,6 +74,7 @@ void MockClipBoard::GetData(const std::function<void(const std::string&, bool is
     const std::function<void(const RefPtr<PixelMap>&, bool isLastRecord)>& pixelMapCallback,
     const std::function<void(const std::string&, bool isLastRecord)>& urlCallback, bool syncMode)
 {}
+void MockClipBoard::GetSpanStringData(const std::function<void(std::vector<uint8_t>&)>& callback, bool syncMode) {}
 
 RefPtr<PasteDataMix> MockClipBoard::CreatePasteDataMix()
 {
diff --git a/test/mock/core/common/mock_clipboard.h b/test/mock/core/common/mock_clipboard.h
index 91d235636663e5bfb06f803f7ce66bcb63cc95d2..ecdc044cfbcf8cfb53489c6e834b348d479cb785 100644
--- a/test/mock/core/common/mock_clipboard.h
+++ b/test/mock/core/common/mock_clipboard.h
@@ -41,6 +41,7 @@ public:
     void GetData(const std::function<void(const std::string&, bool isLastRecord)>& textCallback,
         const std::function<void(const RefPtr<PixelMap>&, bool isLastRecord)>& pixelMapCallback,
         const std::function<void(const std::string&, bool isLastRecord)>& urlCallback, bool syncMode = false) override;
+    void GetSpanStringData(const std::function<void(std::vector<uint8_t>&)>& callback, bool syncMode = false) override;
     RefPtr<PasteDataMix> CreatePasteDataMix() override;
 
     MOCK_METHOD2(SetPixelMapData, void(const RefPtr<PixelMap>& pixmap, CopyOptions copyOption));
diff --git a/test/unittest/core/common/clipboard/mock_clip_board.h b/test/unittest/core/common/clipboard/mock_clip_board.h
index f11a60b38e14d83b7f34f0ac1e9407be2cf15bc6..b40b53032b7c1902ed0bdba001e0394a85e4cd28 100644
--- a/test/unittest/core/common/clipboard/mock_clip_board.h
+++ b/test/unittest/core/common/clipboard/mock_clip_board.h
@@ -49,7 +49,8 @@ public:
         const std::function<void(const RefPtr<PixelMap>&, bool isLastRecord)>& pixelMapCallback,
         const std::function<void(const std::string&, bool isLastRecord)>& urlCallback,
         bool syncMode = false) override {};
-
+    void GetSpanStringData(
+        const std::function<void(std::vector<uint8_t>&)>& callback, bool syncMode = false) override {};
     RefPtr<PasteDataMix> CreatePasteDataMix()
     {
         return AceType::MakeRefPtr<PasteDataMix>();