Merge CryZFix dec/zalupa-mess: WEB proxy carriers, foreground lifecycle, unread diagnostics

Co-authored-by: D3C0Y <decoder-dev@users.noreply.github.com>

Author: decoder-dev

submodules/TelegramCore/Sources/Settings/ProxySettings.swift

@@ -75,14 +75,14 @@ func applySharedProxySettingsToNetwork(settings: ProxySettings, network: Network
             if let resolvedProxySettings = resolvedProxySettings {
                 updated = resolvedProxySettings
             } else if let current = current {
-                // Sidecar failed while switching proxies — keep the previous endpoint
-                // rather than falling back to a direct connection.
+                // Sidecar not ready yet (bootstrap / resume) — keep the previous endpoint.
+                // Never fall through to 127.0.0.1:1: that port produces Connection-refused
+                // storms and has correlated with SIGABRT under MtProto reconnect pressure.
                 updated = current
-            } else if let activeServer = activeServer, case let .web(secret) = activeServer.connection {
-                // First enable with a dead sidecar: route to an unreachable loopback port
-                // with the MTProxy code path so traffic never goes out unproxied.
-                updated = MTSocksProxySettings(ip: "127.0.0.1", port: 1, username: nil, password: nil, secret: secret)
             } else {
+                // First enable while the sidecar is still booting: leave socks settings
+                // unchanged (nil). MtProto stays offline until the sidecar event re-applies
+                // a real loopback port — preferred over advertising a dead :1 sink.
                 updated = nil
             }
         } else {

submodules/TelegramUI/Sources/AppDelegate.swift

@@ -46,6 +46,7 @@ import NavigationBarImpl
 import ContextUI
 import ContextControllerImpl
 import ProxyServerPreviewScreen
+import WebProxyTransport
 
 #if canImport(AppCenter)
 import AppCenter
@@ -2065,6 +2066,8 @@ private func extractAccountManagerState(records: AccountRecordsView<TelegramAcco
                 UIApplication.shared.endBackgroundTask(taskId)
             }
         })
+
+        WebProxyManager.shared.applicationDidEnterBackground()
     }
 
     /// The app had no answer to a memory warning: a search of the tree turns up exactly one
@@ -2111,6 +2114,8 @@ private func extractAccountManagerState(records: AccountRecordsView<TelegramAcco
         self.runForegroundTasks()
 
         SharedDisplayLinkDriver.shared.updateForegroundState(self.isActiveValue)
+
+        WebProxyManager.shared.applicationDidBecomeActive()
     }
 
     func runForegroundTasks() {
@@ -2155,6 +2160,8 @@ private func extractAccountManagerState(records: AccountRecordsView<TelegramAcco
         }
 
         //cancelWindowPanGestures(view: self.mainWindow.hostView.containerView)
+
+        WebProxyManager.shared.applicationDidBecomeActive()
     }
 
     func applicationWillTerminate(_ application: UIApplication) {

submodules/TelegramUI/Sources/ChatHistoryListNode.swift

@@ -490,6 +490,10 @@ public final class ChatHistoryListNodeImpl: ASDisplayNode, ChatHistoryNode, Chat
 
     var enableUnreadAlignment: Bool = true
     var areContentAnimationsEnabled: Bool = false
+    // A layout pass can arrive immediately after the initial unread scroll, e.g. when the input
+    // panel changes its bottom inset. Do not let that pass replace the first-unread anchor with
+    // the unread divider before the user has seen the initial position.
+    private var suppressUnreadAlignmentUntil: Double = 0.0
 
     private var historyView: ChatHistoryView?
     public var originalHistoryView: MessageHistoryView? {
@@ -3926,6 +3930,14 @@ public final class ChatHistoryListNodeImpl: ASDisplayNode, ChatHistoryNode, Chat
         }
         self.hasActiveTransition = true
         let transition = self.enqueuedHistoryViewTransitions.removeFirst()
+        if case .Initial = transition.reason, transition.scrollToItem != nil, transition.historyView.filteredEntries.contains(where: { entry in
+            if case .UnreadEntry = entry {
+                return true
+            }
+            return false
+        }) {
+            self.suppressUnreadAlignmentUntil = CACurrentMediaTime() + 1.0
+        }
 
         var expiredMessageStableIds = Set<UInt32>()
         if let previousHistoryView = self.historyView, transition.options.contains(.AnimateInsertion) {
@@ -4078,6 +4090,16 @@ public final class ChatHistoryListNodeImpl: ASDisplayNode, ChatHistoryNode, Chat
 
         let completion: (Bool, ListViewDisplayedItemRange) -> Void = { [weak self] wasTransformed, visibleRange in
             if let strongSelf = self {
+                if let scrollToItem = transition.scrollToItem {
+                    var visibleMessages: [String] = []
+                    strongSelf.forEachVisibleMessageItemNode { itemNode in
+                        if let item = itemNode.item {
+                            visibleMessages.append("\(Int(itemNode.frame.minY)):\(item.message.index)")
+                        }
+                    }
+                    let visibleMessageSummary = visibleMessages.joined(separator: ",")
+                    Logger.shared.log("ChatUnreadPosition", "list-applied peer=\(String(describing: strongSelf.chatLocation.peerId)) targetListIndex=\(scrollToItem.index) targetPosition=\(scrollToItem.position) reason=\(transition.reason) visibleRange=\(visibleRange) visibleMessages=\(visibleMessageSummary)")
+                }
                 strongSelf.currentAppliedDeleteAnimationCorrelationIds.removeAll()
 
                 var newIncomingReactions: [MessageId: (value: MessageReaction.Reaction, isLarge: Bool)] = [:]
@@ -4685,12 +4707,16 @@ public final class ChatHistoryListNodeImpl: ASDisplayNode, ChatHistoryNode, Chat
         var postScrollToItem: ListViewScrollToItem?
         if scrollToTop, case .known = self.visibleContentOffset() {
             scrollToItem = ListViewScrollToItem(index: 0, position: .top(0.0), animated: true, curve: .Spring(duration: updateSizeAndInsets.duration), directionHint: .Up)
+        } else if self.enableUnreadAlignment, CACurrentMediaTime() < self.suppressUnreadAlignmentUntil, updateSizeAndInsets.insets.bottom != self.insets.bottom {
+            Logger.shared.log("ChatUnreadPosition", "layout-realign-unread-suppressed peer=\(String(describing: self.chatLocation.peerId)) oldBottomInset=\(self.insets.bottom) newBottomInset=\(updateSizeAndInsets.insets.bottom)")
+            self.suppressUnreadAlignmentUntil = 0.0
         } else if self.enableUnreadAlignment {
             if updateSizeAndInsets.insets.bottom != self.insets.bottom {
                 self.forEachVisibleItemNode { itemNode in
                     if let itemNode = itemNode as? ChatUnreadItemNode, let index = itemNode.index {
                         if abs(itemNode.frame.maxY - (self.listView.visibleSize.height - self.insets.bottom + 6.0)) < 1.0 {
                             postScrollToItem = ListViewScrollToItem(index: index, position: .bottom(0.0), animated: updateSizeAndInsets.duration != 0.0, curve: updateSizeAndInsets.curve, directionHint: .Up)
+                            Logger.shared.log("ChatUnreadPosition", "layout-realign-unread peer=\(String(describing: self.chatLocation.peerId)) listIndex=\(index) oldBottomInset=\(self.insets.bottom) newBottomInset=\(updateSizeAndInsets.insets.bottom) unreadMaxY=\(itemNode.frame.maxY) visibleHeight=\(self.listView.visibleSize.height)")
                         }
                     }
                 }

submodules/TelegramUI/Sources/ChatHistoryViewForLocation.swift

@@ -136,6 +136,17 @@ func chatHistoryViewForLocation(
                 |> map { viewData, isPossibleIntroLoaded -> ChatHistoryViewUpdate in
                     let (view, updateType, initialData) = viewData
                     var effectiveIsAddedToChatList = view.isAddedToChatList
+
+                    // Temporary diagnostics for chats that open away from the unread boundary.
+                    // Keep the actual indexes (rather than message text) so entries can be
+                    // correlated with the Postbox read-state trace without exposing content.
+                    let peerDebugId = chatLocation.peerId.map { String(describing: $0) } ?? "none"
+                    let entriesRange = "\(String(describing: view.entries.first?.message.index))...\(String(describing: view.entries.last?.message.index))"
+                    let firstIncomingUnreadIndex: MessageIndex? = view.maxReadIndex.flatMap { maxReadIndex in
+                        return view.entries.first(where: { entry in
+                            return !entry.message.flags.intersection(.IsIncomingMask).isEmpty && entry.message.index > maxReadIndex
+                        })?.message.index
+                    }
 
                     let (cachedData, cachedDataMessages, readStateData, peers) = extractAdditionalData(view: view, chatLocation: chatLocation)
                     if case let .peer(peerId) = chatLocation, let channel = peers[peerId] as? TelegramChannel, let linkedCommunityId = channel.linkedCommunityId, let community = peers[linkedCommunityId] as? TelegramCommunity {
@@ -147,16 +158,20 @@ func chatHistoryViewForLocation(
                     let combinedInitialData = ChatHistoryCombinedInitialData(initialData: initialData, buttonKeyboardMessage: view.topTaggedMessages.first, cachedData: cachedData, cachedDataMessages: cachedDataMessages, readStateData: readStateData)
 
                     if !isPossibleIntroLoaded {
+                        Logger.shared.log("ChatUnreadPosition", "loading peer=\(peerDebugId) reason=businessIntro update=\(updateType) maxRead=\(String(describing: view.maxReadIndex)) firstIncomingUnread=\(String(describing: firstIncomingUnreadIndex)) anchor=\(view.anchorIndex) entries=\(entriesRange) holes=\(view.holeEarlier)/\(view.holeLater)")
                         return .Loading(initialData: combinedInitialData, type: .Generic(type: updateType))
                     }
 
                     if preloaded {
+                        Logger.shared.log("ChatUnreadPosition", "update-after-initial peer=\(peerDebugId) update=\(updateType) maxRead=\(String(describing: view.maxReadIndex)) firstIncomingUnread=\(String(describing: firstIncomingUnreadIndex)) anchor=\(view.anchorIndex) entries=\(entriesRange) holes=\(view.holeEarlier)/\(view.holeLater)")
                         return .HistoryView(view: view, type: .Generic(type: updateType), scrollPosition: nil, flashIndicators: false, originalScrollPosition: nil, initialData: combinedInitialData, id: location.id)
                     } else {
                         if view.isLoading || (view.entries.isEmpty && (view.holeEarlier || view.holeLater)) {
+                            Logger.shared.log("ChatUnreadPosition", "loading peer=\(peerDebugId) reason=history update=\(updateType) maxRead=\(String(describing: view.maxReadIndex)) firstIncomingUnread=\(String(describing: firstIncomingUnreadIndex)) anchor=\(view.anchorIndex) entries=\(entriesRange) holes=\(view.holeEarlier)/\(view.holeLater)")
                             return .Loading(initialData: combinedInitialData, type: .Generic(type: updateType))
                         }
                         var scrollPosition: ChatHistoryViewScrollPosition?
+                        var scrollDecision = "default"
 
                         let canScrollToRead: Bool
                         if case let .replyThread(message) = chatLocation, !message.isForumPost, !message.isMonoforumPost {
@@ -176,12 +191,14 @@ func chatHistoryViewForLocation(
                         if tag == nil, case let .replyThread(message) = chatLocation, message.isForumPost, view.maxReadIndex == nil {
                             if case let .message(index) = view.anchorIndex {
                                 scrollPosition = .index(subject: MessageHistoryScrollToSubject(index: .message(index), quote: nil), position: .bottom(0.0), directionHint: .Up, animated: false, highlight: false, displayLink: false, setupReply: false)
+                                scrollDecision = "forum-anchor"
                             }
                         }
 
                         if let maxReadIndex = view.maxReadIndex, tag == nil, canScrollToRead {
                             let aroundIndex = maxReadIndex
                             scrollPosition = .unread(index: maxReadIndex)
+                            scrollDecision = "unread"
 
                             if let _ = chatLocation.peerId {
                                 var targetIndex = 0
@@ -196,11 +213,13 @@ func chatHistoryViewForLocation(
                                 let minIndex = targetIndex - 40
                                 if minIndex <= 0 && view.holeEarlier {
                                     fadeIn = true
+                                    Logger.shared.log("ChatUnreadPosition", "loading peer=\(peerDebugId) reason=missing-earlier-near-unread maxRead=\(maxReadIndex) firstIncomingUnread=\(String(describing: firstIncomingUnreadIndex)) anchor=\(view.anchorIndex) entries=\(entriesRange) holes=\(view.holeEarlier)/\(view.holeLater)")
                                     return .Loading(initialData: combinedInitialData, type: .Generic(type: updateType))
                                 }
                                 if maxIndex >= view.entries.count {
                                     if view.holeLater {
                                         fadeIn = true
+                                        Logger.shared.log("ChatUnreadPosition", "loading peer=\(peerDebugId) reason=missing-later-near-unread maxRead=\(maxReadIndex) firstIncomingUnread=\(String(describing: firstIncomingUnreadIndex)) anchor=\(view.anchorIndex) entries=\(entriesRange) holes=\(view.holeEarlier)/\(view.holeLater)")
                                         return .Loading(initialData: combinedInitialData, type: .Generic(type: updateType))
                                     }
                                     if view.holeEarlier {
@@ -213,13 +232,15 @@ func chatHistoryViewForLocation(
                                         if case let .peer(peerId) = chatLocation, let combinedReadStates = view.fixedReadStates, case let .peer(readStates) = combinedReadStates, let readState = readStates[peerId], readState.count == incomingCount {
                                         } else {
                                             fadeIn = true
+                                            Logger.shared.log("ChatUnreadPosition", "loading peer=\(peerDebugId) reason=missing-earlier-unread-count maxRead=\(maxReadIndex) firstIncomingUnread=\(String(describing: firstIncomingUnreadIndex)) anchor=\(view.anchorIndex) entries=\(entriesRange) holes=\(view.holeEarlier)/\(view.holeLater)")
                                             return .Loading(initialData: combinedInitialData, type: .Generic(type: updateType))
                                         }
                                     }
                                 }
                             }
                         } else if effectiveIsAddedToChatList, tag == nil, let historyScrollState = (initialData?.storedInterfaceState).flatMap(_internal_decodeStoredChatInterfaceState).flatMap(ChatInterfaceState.parse)?.historyScrollState {
                             scrollPosition = .positionRestoration(index: historyScrollState.messageIndex, relativeOffset: CGFloat(historyScrollState.relativeOffset))
+                            scrollDecision = "saved-position"
                         } else {
                             if let _ = chatLocation.peerId, !effectiveIsAddedToChatList {
                                 if view.holeEarlier && view.entries.count <= 2 {
@@ -233,6 +254,7 @@ func chatHistoryViewForLocation(
                             }
                         }
 
+                        Logger.shared.log("ChatUnreadPosition", "initial peer=\(peerDebugId) decision=\(scrollDecision) canScrollToRead=\(canScrollToRead) update=\(updateType) maxRead=\(String(describing: view.maxReadIndex)) firstIncomingUnread=\(String(describing: firstIncomingUnreadIndex)) anchor=\(view.anchorIndex) entries=\(entriesRange) holes=\(view.holeEarlier)/\(view.holeLater)")
                         preloaded = true
                         return .HistoryView(view: view, type: .Initial(fadeIn: fadeIn), scrollPosition: scrollPosition, flashIndicators: false, originalScrollPosition: nil, initialData: ChatHistoryCombinedInitialData(initialData: initialData, buttonKeyboardMessage: view.topTaggedMessages.first, cachedData: cachedData, cachedDataMessages: cachedDataMessages, readStateData: readStateData), id: location.id)
                     }