聊天界面

/// Replace the current legacy input node with a freshly-built native node, transferring first-responder
/// status (become-new BEFORE resign-old, so the keyboard is not dismissed and re-presented). The caller sets
/// content on the new node immediately afterwards.
private func replaceLegacyWithNative() {
    guard let old = self.richTextInputNode, !old.usesNativeRichTextEngine else {
        return
    }
    let wasFirstResponder = old.isInputFirstResponder
    self.loadTextInputNode(useNative: true)
    guard let new = self.richTextInputNode, new !== old else {
        return
    }
    if wasFirstResponder {
        new.makeInputFirstResponder()
    }
    old.resignInputFirstResponder()
    old.asNode.removeFromSupernode()
}

let horizontalCurve = ChatMessageTransitionNodeImpl.horizontalAnimationCurve
let horizontalTransition: ContainedViewLayoutTransition = .animated(duration: horizontalDuration, curve: horizontalCurve)
let verticalCurve = ChatMessageTransitionNodeImpl.verticalAnimationCurve
let verticalTransition: ContainedViewLayoutTransition = .animated(duration: verticalDuration, curve: verticalCurve)

let combinedTransition = CombinedTransition(horizontal: horizontalTransition, vertical: verticalTransition)

self.containerNode.frame = targetAbsoluteRect.offsetBy(dx: -self.contextSourceNode.contentRect.minX, dy: -self.contextSourceNode.contentRect.minY)
self.contextSourceNode.updateAbsoluteRect?(self.containerNode.frame, UIScreen.main.bounds.size)

self.containerNode.layer.animatePosition(from: CGPoint(x: 0.0, y: sourceAbsoluteRect.maxY - targetAbsoluteRect.maxY), to: CGPoint(), duration: verticalDuration, delay: delay, mediaTimingFunction: verticalCurve.mediaTimingFunction, additive: true, force: true, completion: { [weak self] _ in
    guard let strongSelf = self else {
        return
    }
    strongSelf.endAnimation()
})
self.containerNode.layer.animatePosition(from: CGPoint(x: sourceAbsoluteRect.minX - targetAbsoluteRect.minX, y: 0.0), to: CGPoint(), duration: horizontalDuration, delay: delay, mediaTimingFunction: horizontalCurve.mediaTimingFunction, additive: true)

if let itemNode = self.itemNode as? ChatMessageBubbleItemNode {
    itemNode.animateContentFromTextInputField(
        textInput: ChatMessageBubbleItemNode.AnimationTransitionTextInput(
            backgroundView: textInput.backgroundView,
            contentView: textInput.contentView,
            sourceRect: textInput.sourceRect,

let combinedTransition = CombinedTransition(horizontal: .animated(duration: horizontalDuration, curve: ChatMessageTransitionNodeImpl.horizontalAnimationCurve), vertical: .animated(duration: verticalDuration, curve: ChatMessageTransitionNodeImpl.verticalAnimationCurve))

if let itemNode = self.itemNode as? ChatMessageBubbleItemNode {
    itemNode.animateContentFromMediaInput(snapshotView: snapshotView, transition: combinedTransition)
}

self.containerNode.frame = targetAbsoluteRect.offsetBy(dx: -self.contextSourceNode.contentRect.minX, dy: -self.contextSourceNode.contentRect.minY)

snapshotView.center = targetAbsoluteRect.center.offsetBy(dx: -self.containerNode.frame.minX, dy: -self.containerNode.frame.minY)
self.containerNode.view.addSubview(snapshotView)

self.contextSourceNode.updateAbsoluteRect?(self.containerNode.frame, UIScreen.main.bounds.size)

self.containerNode.layer.animatePosition(from: CGPoint(x: 0.0, y: sourceAbsoluteRect.midY - targetAbsoluteRect.midY), to: CGPoint(), duration: horizontalDuration, delay: delay, mediaTimingFunction: ChatMessageTransitionNodeImpl.horizontalAnimationCurve.mediaTimingFunction, additive: true, force: true)
self.containerNode.layer.animatePosition(from: CGPoint(x: sourceAbsoluteRect.midX - targetAbsoluteRect.midX, y: 0.0), to: CGPoint(), duration: verticalDuration, delay: delay, mediaTimingFunction: ChatMessageTransitionNodeImpl.verticalAnimationCurve.mediaTimingFunction, additive: true, force: true, completion: { [weak self] _ in
    guard let strongSelf = self else {
        return
    }
    strongSelf.endAnimation()
})

combinedTransition.horizontal.animateTransformScale(node: self.contextSourceNode.contentNode, from: CGPoint(x: sourceBackgroundAbsoluteRect.width / targetAbsoluteRect.width, y: sourceBackgroundAbsoluteRect.height / targetAbsoluteRect.height))

combinedTransition.horizontal.updateTransformScale(layer: snapshotView.layer, scale: CGPoint(x: 1.0 / (sourceBackgroundAbsoluteRect.width / targetAbsoluteRect.width), y: 1.0 / (sourceBackgroundAbsoluteRect.height / targetAbsoluteRect.height)))

// No snapshot of the blob: it flies itself, in its own container, along the same path as the
// play button here in the chat, crossfading into it at the start.
let sourceAbsoluteRect = convertRenderedSourceRect(localRect, from: container, toAnimatingView: self.view)

let combinedTransition = CombinedTransition(horizontal: .animated(duration: horizontalDuration, curve: ChatMessageTransitionNodeImpl.horizontalAnimationCurve), vertical: .animated(duration: verticalDuration, curve: ChatMessageTransitionNodeImpl.verticalAnimationCurve))

if let itemNode = self.itemNode as? ChatMessageBubbleItemNode {
    if let contextContainer = itemNode.animateFromMicInput(sourceSize: sourceAbsoluteRect.size, transition: combinedTransition) {
        self.containerNode.addSubnode(contextContainer.contentNode)

        let targetAbsoluteRect = contextContainer.view.convertAcrossWindows(contextContainer.contentRect, to: self.view)

        self.containerNode.frame = targetAbsoluteRect.offsetBy(dx: -contextContainer.contentRect.minX, dy: -contextContainer.contentRect.minY)
        contextContainer.updateAbsoluteRect?(self.containerNode.frame, UIScreen.main.bounds.size)

        let _ = audioMicInput.micButton.animateDecorationToSentMessage(targetRect: targetAbsoluteRect, in: self.view, duration: verticalDuration, horizontalCurve: ChatMessageTransitionNodeImpl.horizontalAnimationCurve, verticalCurve: ChatMessageTransitionNodeImpl.verticalAnimationCurve)

        self.containerNode.layer.animatePosition(from: CGPoint(x: 0.0, y: sourceAbsoluteRect.midY - targetAbsoluteRect.midY), to: CGPoint(), duration: verticalDuration, delay: delay, mediaTimingFunction: ChatMessageTransitionNodeImpl.verticalAnimationCurve.mediaTimingFunction, additive: true, force: true, completion: { [weak self, weak contextContainer] _ in
            guard let strongSelf = self else {
                return
            }
            if let contextContainer = contextContainer {
                contextContainer.isExtractedToContextPreview = false
                contextContainer.isExtractedToContextPreviewUpdated?(false)
                contextContainer.addSubnode(contextContainer.contentNode)

let position = framesAndPositions[mosaicIndex].1

let topLeft: ChatMessageBubbleContentMosaicNeighbor
let topRight: ChatMessageBubbleContentMosaicNeighbor
let bottomLeft: ChatMessageBubbleContentMosaicNeighbor
let bottomRight: ChatMessageBubbleContentMosaicNeighbor

switch firstNodeTopPosition {
case .Neighbour:
    topLeft = .merged
    topRight = .merged
case .BubbleNeighbour:
    topLeft = .mergedBubble
    topRight = .mergedBubble
case let .None(status):
    if position.contains(.top) && position.contains(.left) {
        switch status {
        case .Left, .Both:
            topLeft = .mergedBubble
        case .Right:
            topLeft = .none(tail: false)
        case .None:
            topLeft = .none(tail: false)
        }

let topNodeMergeStatus: ChatMessageBubbleMergeStatus = mergedTop.merged ? (incoming ? .Left : .Right) : .None(incoming ? .Incoming : .Outgoing)
var bottomNodeMergeStatus: ChatMessageBubbleMergeStatus = mergedBottom.merged ? (incoming ? .Left : .Right) : .None(incoming ? .Incoming : .Outgoing)

let bubbleReactions: ReactionsMessageAttribute
if needReactions || forceReactionsOutside {
    bubbleReactions = mergedMessageReactions(attributes: item.message.attributes, isTags: item.message.areReactionsTags(accountPeerId: item.context.account.peerId)) ?? ReactionsMessageAttribute(canViewList: false, isTags: false, reactions: [], recentPeers: [], topPeers: [])
} else {
    bubbleReactions = ReactionsMessageAttribute(canViewList: false, isTags: false, reactions: [], recentPeers: [], topPeers: [])
}
if !bubbleReactions.reactions.isEmpty && !item.presentationData.isPreview {
    if incoming {
        bottomNodeMergeStatus = .Left
    } else {
        bottomNodeMergeStatus = .Right
    }
}

var currentCredibilityIcon: (EmojiStatusComponent.Content, UIColor?)?

let displayEphemeralBadge: Bool
if ephemeralBadgeText != nil && !mergedTop.merged && !hidesHeaders && item.message.adAttribute == nil {

var textFieldHeight: CGFloat
var isOverflow = false
if let richTextInputNode = self.richTextInputNode {
    let maxTextWidth = width - textFieldInsets.left - textFieldInsets.right - actualTextInputViewInternalInsets.left - actualTextInputViewInternalInsets.right
    let measuredHeight = richTextInputNode.textHeightForWidth(maxTextWidth, rightInset: textInputViewRealInsets.right)
    
    let unboundTextFieldHeight = max(textFieldMinHeight, ceil(measuredHeight))
    
    let maxNumberOfLines = max(1, min(12, (Int(fieldMaxHeight - 11.0) - 33) / 22))
    
    let updatedMaxHeight = (CGFloat(maxNumberOfLines) * (22.0 + 2.0) + 10.0)
    
    textFieldHeight = max(textFieldMinHeight, unboundTextFieldHeight)
    isOverflow = textFieldHeight > updatedMaxHeight
    textFieldHeight = min(textFieldHeight, updatedMaxHeight)
} else {
    textFieldHeight = textFieldMinHeight
}

return (accessoryButtonsWidth, textFieldHeight, isOverflow)

public func micButtonInteractionBegan() {
    if self.fadeDisabled {
        self.recordingDisabled()
    } else {
        self.modeTimeoutTimer?.invalidate()
        let modeTimeoutTimer = SwiftSignalKit.Timer(timeout: 0.19, repeat: false, completion: { [weak self] in
            if let strongSelf = self {
                strongSelf.modeTimeoutTimer = nil
                strongSelf.beginRecording()
            }
        }, queue: Queue.mainQueue())
        self.modeTimeoutTimer = modeTimeoutTimer
        modeTimeoutTimer.start()
    }
}

// ...
public func micButtonInteractionCompleted(_ velocity: CGPoint) {
    if let modeTimeoutTimer = self.modeTimeoutTimer {
        modeTimeoutTimer.invalidate()
        self.modeTimeoutTimer = nil
        self.switchMode()
    }
    self.endRecording(true)
}

public func micButtonInteractionUpdate(_ offset: CGPoint) {
    self.controlsOffset = offset.x
    self.offsetRecordingControls()
}

public func micButtonInteractionUpdateCancelTranslation(_ translation: CGFloat) {
    self.cancelTranslation = translation
    self.updateCancelTranslation()
}

public func micButtonInteractionLocked() {
    self.updateLocked(true)
}

public func micButtonInteractionRequestedLockedAction() {
}

public func micButtonInteractionStopped() {
    self.stopRecording()
}

public func micButtonShouldLock() -> Bool {
    return true
}

self.textInputPanelNode?.switchToTextInputIfNeeded = { [weak self] in
    guard let strongSelf = self, let interfaceInteraction = strongSelf.interfaceInteraction else {
        return
    }
    
    if let inputNode = strongSelf.inputNode as? ChatEntityKeyboardInputNode, !inputNode.canSwitchToTextInputAutomatically {
        return
    }
    
    interfaceInteraction.updateInputModeAndDismissedButtonKeyboardMessageId({ state in
        switch state.inputMode {
        case .media:
            return (.text, state.keyboardButtonsMessage?.id)
        default:
            return (state.inputMode, state.keyboardButtonsMessage?.id)
        }
    })
}

public override func updateLayout(width: CGFloat, leftInset: CGFloat, rightInset: CGFloat, bottomInset: CGFloat, standardInputHeight: CGFloat, inputHeight: CGFloat, maximumHeight: CGFloat, inputPanelHeight: CGFloat, transition: ContainedViewLayoutTransition, interfaceState: ChatPresentationInterfaceState, layoutMetrics: LayoutMetrics, deviceMetrics: DeviceMetrics, isVisible: Bool, isExpanded: Bool) -> (CGFloat, CGFloat) {
    self.currentState = (width, leftInset, rightInset, bottomInset, standardInputHeight, inputHeight, maximumHeight, inputPanelHeight, interfaceState, layoutMetrics, deviceMetrics, isVisible, isExpanded)

    let innerTransition: ComponentTransition
    if let scheduledInnerTransition = self.scheduledInnerTransition {
        self.scheduledInnerTransition = nil
        innerTransition = scheduledInnerTransition
    } else {
        innerTransition = ComponentTransition(transition)
    }

    let wasMarkedInputCollapsed = self.isMarkInputCollapsed
    self.isMarkInputCollapsed = false

    var expandedHeight = standardInputHeight
    if self.isEmojiSearchActive && !isExpanded {
        expandedHeight += 118.0
    }

    var hiddenInputHeight: CGFloat = 0.0
    if self.hideInput && !self.adjustLayoutForHiddenInput {
        hiddenInputHeight = inputPanelHeight
    }

if let current = self.searchView {
    searchView = current
} else {
    searchViewTransition = .immediate
    searchView = ComponentHostView<EntitySearchContentEnvironment>()
    self.searchView = searchView
    self.addSubview(searchView)
    
    animateIn = true
    component.topPanelExtensionUpdated(0.0, transition)
}

// ...
searchViewTransition.setFrame(view: searchView, frame: CGRect(origin: CGPoint(), size: availableSize))
if animateIn {
    transition.animateAlpha(view: searchView, from: 0.0, to: 1.0)
    transition.animatePosition(view: searchView, from: CGPoint(x: 0.0, y: self.topPanelExtension ?? 0.0), to: CGPoint(), additive: true, completion: nil)
}

if let strongSelf = self, updatedScrollPosition == nil, case .InteractiveChanges = reason, let previous = previous {
    // ONE sample feeds both gates below. They are compared against each other to decide a
    // scroll position, and this runs while a transaction is being PREPARED — so the
    // question is what state the list is in, not where a pass in flight happens to have
    // the content at this instant. On ListViewImpl the settled and presented geometries
    // are the same thing; under a hosting backend, two separate reads would let "am I
    // pinned to the newest message" and "does the content fill the screen" describe
    // different moments of the same animation.
    let settledOffsets = strongSelf.listView.settledContentOffsets()

    if case let .known(offset) = settledOffsets.top, abs(offset) <= 0.9 {
        var fillsScreen = true
        switch settledOffsets.bottom {
        case let .known(bottomOffset):
            if bottomOffset <= strongSelf.listView.visibleSize.height - strongSelf.insets.bottom {
                fillsScreen = false
            }
        default:
            break
        }

let _ = self.clientId.swap(nextClientId)
nextClientId += 1

self.listView.updateVisibleItemRange(force: true)
}

func refocusOnUnreadMessagesIfNeeded() {
    self.forEachItemNode({ itemNode in
        if let itemNode = itemNode as? ChatUnreadItemNode {
            self.listView.ensureItemNodeVisible(itemNode, animated: false, overflow: 0.0, curve: .Default(duration: nil))
        }
    })
}

private func maybeInsertPendingAdMessage(historyView: ChatHistoryView, toLaterRange: (Int, Int), toEarlierRange: (Int, Int)) {
    if self.pendingDynamicAdMessages.isEmpty {
        return
    }
    
    var eligibleMessageIndices = Set<MessageIndex>()

private func dequeueHistoryViewTransitions() {
    if self.enqueuedHistoryViewTransitions.isEmpty || self.hasActiveTransition {
        return
    }
    self.hasActiveTransition = true
    let transition = self.enqueuedHistoryViewTransitions.removeFirst()

    // Record live arrivals before creating their content nodes. Loading another history
    // window (including a reply jump) must never look like a newly received transfer.
    if case .InteractiveChanges = transition.reason,
       !transition.insertItems.isEmpty,
       self.controllerInteraction.canReadHistory,
       let previous = self.historyView,
       previous.id == transition.historyView.id,
       !previous.originalView.isLoading, previous.originalView.laterId == nil,
       transition.historyView.originalView.laterId == nil {
        let previousIds = Set(previous.originalView.entries.map { $0.message.id })
        let previousLastIndex = previous.originalView.entries.map { $0.message.index }.max()
        for entry in transition.historyView.originalView.entries {
            let message = entry.message

if let currentMessage = currentMessage {
    self.chatHistoryLocationValue = ChatHistoryLocationInput(content: .Scroll(subject: MessageHistoryScrollToSubject(index: .message(currentMessage.index), quote: nil), anchorIndex: .message(currentMessage.index), sourceIndex: .upperBound, scrollPosition: .top(0.0), animated: true, highlight: true, setupReply: false), id: self.takeNextHistoryLocationId())
}
}
}

public func scrollToStartOfHistory() {
    self.beganDragging?()
    self.chatHistoryLocationValue = ChatHistoryLocationInput(content: .Scroll(subject: MessageHistoryScrollToSubject(index: .lowerBound, quote: nil), anchorIndex: .lowerBound, sourceIndex: .upperBound, scrollPosition: .bottom(0.0), animated: true, highlight: false, setupReply: false), id: self.takeNextHistoryLocationId())
}

public func scrollToEndOfHistory() {
    self.beganDragging?()
    switch self.visibleContentOffset() {
    case let .known(value) where value <= CGFloat.ulpOfOne:
        break
    default:
        let locationInput = ChatHistoryLocationInput(content: .Scroll(subject: MessageHistoryScrollToSubject(index: .upperBound, quote: nil), anchorIndex: .upperBound, sourceIndex: .lowerBound, scrollPosition: .top(0.0), animated: true, highlight: false, setupReply: false), id: self.takeNextHistoryLocationId())
        self.chatHistoryLocationValue = locationInput
    }
}

public func scrollToMessage(from fromIndex: MessageIndex, to toIndex: MessageIndex, animated: Bool, highlight: Bool = true, quote: (string: String, offset: Int?)? = nil, subject: EngineMessageReplyInnerSubject? = nil, scrollPosition: ListViewScrollPosition = .center(.bottom), setupReply: Bool = false) {
    self.chatHistoryLocationValue = ChatHistoryLocationInput(content: .Scroll(subject: MessageHistoryScrollToSubject(index: .message(toIndex), quote: quote.flatMap { quote in MessageHistoryScrollToSubject.Quote(string: quote.string, offset: quote.offset) }, subject: subject, setupReply: setupReply), anchorIndex: .message(toIndex), sourceIndex: .message(fromIndex), scrollPosition: scrollPosition, animated: animated, highlight: highlight, setupReply: setupReply), id: self.takeNextHistoryLocationId())
}

children.append(contentsOf: [
    UIAction(title: self.strings?.TextFormat_Strikethrough ?? "Strikethrough", image: nil) { [weak richTextInputNode] _ in
        richTextInputNode?.performFormatAction(.strikethrough)
    },
    UIAction(title: self.strings?.TextFormat_Underline ?? "Underline", image: nil) { [weak richTextInputNode] _ in
        richTextInputNode?.performFormatAction(.underline)
    }
])
children.append(UIAction(title: self.strings?.TextFormat_Code ?? "Code", image: nil) { [weak richTextInputNode] _ in
    richTextInputNode?.performFormatAction(.code)
})

let formatMenu = UIMenu(title: self.strings?.TextFormat_Format ?? "Format", image: nil, children: children)

// Drop the editor's built-in "Format" submenu by its language-independent identifier, then
// splice in the composer's after the system Cut/Copy/Paste actions.
var elements = defaultElements.filter { ($0 as? UIMenu)?.identifier != UIMenu.Identifier("org.telegram.RichTextEditor.format") }
let insertIndex = min(1, elements.count)
elements.insert(formatMenu, at: insertIndex)
return elements
}

self.panRecognizer = recognizer
self.view.addGestureRecognizer(recognizer)

self.view.disablesInteractiveTransitionGestureRecognizerNow = { [weak self] in
    guard let strongSelf = self else {
        return false
    }
    if let _ = strongSelf.chatPresentationInterfaceState.inputTextPanelState.mediaRecordingState {
        return true
    }
    var hasChatThemeScreen = false
    strongSelf.controller?.window?.forEachController { c in
        if c is ChatThemeScreen {
            hasChatThemeScreen = true
        }
    }
    if hasChatThemeScreen {
        return true
    }
    
    return false
}
}