Merge commit '7621e2f8dec938cf48181c8b10afc9b01f444e68' into beta

submodules/SettingsUI/Sources/Privacy and Security/Recent Sessions/ItemListRecentSessionItem.swift

@@ -0,0 +1,626 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import TelegramCore
+import TelegramPresentationData
+import ItemListUI
+import PresentationDataUtils
+import TelegramStringFormatting
+
+struct ItemListRecentSessionItemEditing: Equatable {
+    let editable: Bool
+    let editing: Bool
+    let revealed: Bool
+    
+    static func ==(lhs: ItemListRecentSessionItemEditing, rhs: ItemListRecentSessionItemEditing) -> Bool {
+        if lhs.editable != rhs.editable {
+            return false
+        }
+        if lhs.editing != rhs.editing {
+            return false
+        }
+        if lhs.revealed != rhs.revealed {
+            return false
+        }
+        return true
+    }
+}
+
+enum ItemListRecentSessionItemText {
+    case presence
+    case text(String)
+    case none
+}
+
+final class ItemListRecentSessionItem: ListViewItem, ItemListItem {
+    let presentationData: ItemListPresentationData
+    let systemStyle: ItemListSystemStyle
+    let dateTimeFormat: PresentationDateTimeFormat
+    let session: RecentAccountSession
+    let enabled: Bool
+    let editable: Bool
+    let editing: Bool
+    let revealed: Bool
+    let sectionId: ItemListSectionId
+    let setSessionIdWithRevealedOptions: (Int64?, Int64?) -> Void
+    let removeSession: (Int64) -> Void
+    let action: (() -> Void)?
+    
+    init(presentationData: ItemListPresentationData, systemStyle: ItemListSystemStyle, dateTimeFormat: PresentationDateTimeFormat, session: RecentAccountSession, enabled: Bool, editable: Bool, editing: Bool, revealed: Bool, sectionId: ItemListSectionId, setSessionIdWithRevealedOptions: @escaping (Int64?, Int64?) -> Void, removeSession: @escaping (Int64) -> Void, action: (() -> Void)?) {
+        self.presentationData = presentationData
+        self.systemStyle = systemStyle
+        self.dateTimeFormat = dateTimeFormat
+        self.session = session
+        self.enabled = enabled
+        self.editable = editable
+        self.editing = editing
+        self.revealed = revealed
+        self.sectionId = sectionId
+        self.setSessionIdWithRevealedOptions = setSessionIdWithRevealedOptions
+        self.removeSession = removeSession
+        self.action = action
+    }
+    
+    func nodeConfiguredForParams(async: @escaping (@escaping () -> Void) -> Void, params: ListViewItemLayoutParams, synchronousLoads: Bool, previousItem: ListViewItem?, nextItem: ListViewItem?, completion: @escaping (ListViewItemNode, @escaping () -> (Signal<Void, NoError>?, (ListViewItemApply) -> Void)) -> Void) {
+        async {
+            let node = ItemListRecentSessionItemNode()
+            let (layout, apply) = node.asyncLayout()(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem))
+            
+            node.contentSize = layout.contentSize
+            node.insets = layout.insets
+            
+            Queue.mainQueue().async {
+                completion(node, {
+                    return (nil, { _ in apply(false) })
+                })
+            }
+        }
+    }
+    
+    func updateNode(async: @escaping (@escaping () -> Void) -> Void, node: @escaping () -> ListViewItemNode, params: ListViewItemLayoutParams, previousItem: ListViewItem?, nextItem: ListViewItem?, animation: ListViewItemUpdateAnimation, completion: @escaping (ListViewItemNodeLayout, @escaping (ListViewItemApply) -> Void) -> Void) {
+        Queue.mainQueue().async {
+            if let nodeValue = node() as? ItemListRecentSessionItemNode {
+                let makeLayout = nodeValue.asyncLayout()
+                
+                var animated = true
+                if case .None = animation {
+                    animated = false
+                }
+                
+                async {
+                    let (layout, apply) = makeLayout(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem))
+                    Queue.mainQueue().async {
+                        completion(layout, { _ in
+                            apply(animated)
+                        })
+                    }
+                }
+            }
+        }
+    }
+    
+    public var selectable: Bool = true
+    public func selected(listView: ListView){
+        listView.clearHighlightAnimated(true)
+        
+        if self.enabled {
+            self.action?()
+        }
+    }
+}
+
+func iconForSession(_ session: RecentAccountSession) -> (UIImage?, UIColor?, String?, [String]?) {
+    let platform = session.platform.lowercased()
+    let device = session.deviceModel.lowercased()
+    let systemVersion = session.systemVersion.lowercased()
+
+    if device.contains("xbox") {
+        return (UIImage(bundleImageName: "Settings/Devices/Xbox"), UIColor(rgb: 0x35c759), nil, nil)
+    }
+    if device.contains("chrome") && !device.contains("chromebook") {
+        return (UIImage(bundleImageName: "Settings/Devices/Chrome"), UIColor(rgb: 0x35c759), "device_chrome", ["Vector 20.Vector 20.Обводка 1", "Ellipse 18.Ellipse 18.Обводка 1"])
+    }
+    if device.contains("brave") {
+        return (UIImage(bundleImageName: "Settings/Devices/Brave"), UIColor(rgb: 0xff9500), nil, nil)
+    }
+    if device.contains("vivaldi") {
+        return (UIImage(bundleImageName: "Settings/Devices/Vivaldi"), UIColor(rgb: 0xff3c30), nil, nil)
+    }
+    if device.contains("safari") {
+        return (UIImage(bundleImageName: "Settings/Devices/Safari"), UIColor(rgb: 0x0079ff), "device_safari", ["Com 2.Com 2.Заливка 1"])
+    }
+    if device.contains("firefox") {
+        return (UIImage(bundleImageName: "Settings/Devices/Firefox"), UIColor(rgb: 0xff9500), "device_firefox", nil)
+    }
+    if device.contains("opera") {
+        return (UIImage(bundleImageName: "Settings/Devices/Opera"), UIColor(rgb: 0xff3c30), nil, nil)
+    }
+    if platform.contains("android") {
+        return (UIImage(bundleImageName: "Settings/Devices/Android"), UIColor(rgb: 0x35c759), "device_android", ["Eye L.Eye L.Заливка 1", "Eye R.Eye R.Заливка 1"])
+    }
+    if device.contains("iphone") {
+        return (UIImage(bundleImageName: "Settings/Devices/iPhone"), UIColor(rgb: 0x0079ff), "device_iphone", ["apple.apple.Заливка 1"])
+    }
+    if device.contains("ipad") {
+        return (UIImage(bundleImageName: "Settings/Devices/iPad"), UIColor(rgb: 0x0079ff), "device_ipad", ["apple.apple.Заливка 1"])
+    }
+    if (platform.contains("macos") || systemVersion.contains("macos")) && device.contains("mac") {
+        return (UIImage(bundleImageName: "Settings/Devices/Mac"), UIColor(rgb: 0x0079ff), "device_mac", nil)
+    }
+    if platform.contains("ios") || platform.contains("macos") || systemVersion.contains("macos") {
+        return (UIImage(bundleImageName: "Settings/Devices/iOS"), UIColor(rgb: 0x0079ff), nil, nil)
+    }
+    if platform.contains("ubuntu") || systemVersion.contains("ubuntu") {
+        return (UIImage(bundleImageName: "Settings/Devices/Ubuntu"), UIColor(rgb: 0xff9500), "device_ubuntu", ["Ellipse 25.Ellipse 24.Обводка 1", "Ellipse 24.Ellipse 24.Обводка 1", "Union.Union.Заливка 1"])
+    }
+    if platform.contains("linux") || systemVersion.contains("linux") {
+        return (UIImage(bundleImageName: "Settings/Devices/Linux"), UIColor(rgb: 0x8e8e93), "device_linux", nil)
+    }
+    if platform.contains("windows") || systemVersion.contains("windows") {
+        return (UIImage(bundleImageName: "Settings/Devices/Windows"), UIColor(rgb: 0x0079ff), "device_windows", ["Union.Union.Заливка 1"])
+    }
+    return (UIImage(bundleImageName: "Settings/Devices/Generic"), UIColor(rgb: 0x8e8e93), nil, nil)
+}
+
+private func trimmedLocationName(_ session: RecentAccountSession) -> String {
+    var country = session.country
+    country = country.replacingOccurrences(of: "United Arab Emirates", with: "UAE")
+    return country
+}
+
+class ItemListRecentSessionItemNode: ItemListRevealOptionsItemNode {
+    private let backgroundNode: ASDisplayNode
+    private let topStripeNode: ASDisplayNode
+    private let bottomStripeNode: ASDisplayNode
+    private let highlightedBackgroundNode: ASDisplayNode
+    private var disabledOverlayNode: ASDisplayNode?
+    private let maskNode: ASImageNode
+    
+    let iconNode: ASImageNode
+    private let titleNode: TextNode
+    private let appNode: TextNode
+    private let locationNode: TextNode
+    
+    private let containerNode: ASDisplayNode
+    override var controlsContainer: ASDisplayNode {
+        return self.containerNode
+    }
+    
+    private let activateArea: AccessibilityAreaNode
+    
+    private var layoutParams: (ItemListRecentSessionItem, ListViewItemLayoutParams, ItemListNeighbors)?
+    
+    private var editableControlNode: ItemListEditableControlNode?
+    
+    override public var canBeSelected: Bool {
+        if let item = self.layoutParams?.0, let _ = item.action {
+            return true
+        } else {
+            return false
+        }
+    }
+    
+    init() {
+        self.backgroundNode = ASDisplayNode()
+        self.backgroundNode.isLayerBacked = true
+        
+        self.topStripeNode = ASDisplayNode()
+        self.topStripeNode.isLayerBacked = true
+        
+        self.bottomStripeNode = ASDisplayNode()
+        self.bottomStripeNode.isLayerBacked = true
+        
+        self.maskNode = ASImageNode()
+        self.maskNode.isUserInteractionEnabled = false
+        
+        self.containerNode = ASDisplayNode()
+        
+        self.iconNode = ASImageNode()
+        self.iconNode.cornerRadius = 7.0
+        self.iconNode.clipsToBounds = true
+        
+        self.titleNode = TextNode()
+        self.titleNode.isUserInteractionEnabled = false
+        self.titleNode.contentMode = .left
+        self.titleNode.contentsScale = UIScreen.main.scale
+        
+        self.appNode = TextNode()
+        self.appNode.isUserInteractionEnabled = false
+        self.appNode.contentMode = .left
+        self.appNode.contentsScale = UIScreen.main.scale
+        
+        self.locationNode = TextNode()
+        self.locationNode.isUserInteractionEnabled = false
+        self.locationNode.contentMode = .left
+        self.locationNode.contentsScale = UIScreen.main.scale
+    
+        self.highlightedBackgroundNode = ASDisplayNode()
+        self.highlightedBackgroundNode.isLayerBacked = true
+        
+        self.activateArea = AccessibilityAreaNode()
+        
+        super.init(layerBacked: false, dynamicBounce: false, rotated: false, seeThrough: false)
+        
+        self.addSubnode(self.containerNode)
+        self.containerNode.addSubnode(self.iconNode)
+        self.containerNode.addSubnode(self.titleNode)
+        self.containerNode.addSubnode(self.appNode)
+        self.containerNode.addSubnode(self.locationNode)
+        
+        self.addSubnode(self.activateArea)
+    }
+    
+    func asyncLayout() -> (_ item: ItemListRecentSessionItem, _ params: ListViewItemLayoutParams, _ neighbors: ItemListNeighbors) -> (ListViewItemNodeLayout, (Bool) -> Void) {
+        let makeTitleLayout = TextNode.asyncLayout(self.titleNode)
+        let makeAppLayout = TextNode.asyncLayout(self.appNode)
+        let makeLocationLayout = TextNode.asyncLayout(self.locationNode)
+        let editableControlLayout = ItemListEditableControlNode.asyncLayout(self.editableControlNode)
+        
+        var currentDisabledOverlayNode = self.disabledOverlayNode
+        
+        let currentItem = self.layoutParams?.0
+        
+        return { item, params, neighbors in
+            var updatedTheme: PresentationTheme?
+            
+            let titleFont = Font.medium(floor(item.presentationData.fontSize.itemListBaseFontSize * 16.0 / 17.0))
+            let textFont = Font.regular(floor(item.presentationData.fontSize.itemListBaseFontSize * 14.0 / 17.0))
+            
+            let verticalInset: CGFloat
+            switch item.systemStyle {
+            case .glass:
+                verticalInset = 14.0
+            case .legacy:
+                verticalInset = 10.0
+            }
+            
+            let titleSpacing: CGFloat = 1.0
+            let textSpacing: CGFloat = 3.0
+            
+            if currentItem?.presentationData.theme !== item.presentationData.theme {
+                updatedTheme = item.presentationData.theme
+            }
+            
+            var titleAttributedString: NSAttributedString?
+            var appAttributedString: NSAttributedString?
+            var locationAttributedString: NSAttributedString?
+            
+            let peerRevealOptions: [ItemListRevealOption]
+            if item.editable && item.enabled {
+                peerRevealOptions = [ItemListRevealOption(key: 0, title: item.presentationData.strings.AuthSessions_Terminate, icon: .none, color: item.presentationData.theme.list.itemDisclosureActions.destructive.fillColor, textColor: item.presentationData.theme.list.itemDisclosureActions.destructive.foregroundColor)]
+            } else {
+                peerRevealOptions = []
+            }
+            
+            let rightInset: CGFloat = params.rightInset
+            
+            var appVersion = item.session.appVersion
+            appVersion = appVersion.replacingOccurrences(of: "APPSTORE", with: "").replacingOccurrences(of: "BETA", with: "Beta").trimmingTrailingSpaces()
+            if let openingRoundBraceRange = appVersion.range(of: " ("), let closingRoundBraceRange = appVersion.range(of: ")") {
+                appVersion = appVersion.replacingCharacters(in: openingRoundBraceRange.lowerBound ..< closingRoundBraceRange.upperBound, with: "")
+            }
+            
+            var deviceString = ""
+            if !item.session.deviceModel.isEmpty {
+                deviceString = item.session.deviceModel
+            }
+            
+//            if !item.session.platform.isEmpty {
+//                if !deviceString.isEmpty {
+//                    deviceString += ", "
+//                }
+//                deviceString += item.session.platform
+//            }
+                        
+            var updatedIcon: UIImage?
+            if item.session != currentItem?.session {
+                updatedIcon = iconForSession(item.session).0
+            }
+            
+            let appString = "\(item.session.appName) \(appVersion)"
+            
+            titleAttributedString = NSAttributedString(string: deviceString, font: titleFont, textColor: item.presentationData.theme.list.itemPrimaryTextColor)
+            appAttributedString = NSAttributedString(string: appString, font: textFont, textColor: item.presentationData.theme.list.itemPrimaryTextColor)
+            
+            let label: String
+            if item.session.isCurrent {
+                label = item.presentationData.strings.Presence_online
+            } else {
+                let timestamp = Int32(CFAbsoluteTimeGetCurrent() + NSTimeIntervalSince1970)
+                label = stringForRelativeActivityTimestamp(strings: item.presentationData.strings, dateTimeFormat: item.dateTimeFormat, relativeTimestamp: item.session.activityDate, relativeTo: timestamp)
+            }
+            
+            locationAttributedString = NSAttributedString(string: "\(trimmedLocationName(item.session)) • \(label)", font: textFont, textColor: item.presentationData.theme.list.itemSecondaryTextColor)
+                        
+            let leftInset: CGFloat = 59.0 + params.leftInset
+            
+            var editableControlSizeAndApply: (CGFloat, (CGFloat) -> ItemListEditableControlNode)?
+            
+            let editingOffset: CGFloat
+            if item.editing {
+                let sizeAndApply = editableControlLayout(item.presentationData.theme, false)
+                editableControlSizeAndApply = sizeAndApply
+                editingOffset = sizeAndApply.0
+            } else {
+                editingOffset = 0.0
+            }
+            
+            let (titleLayout, titleApply) = makeTitleLayout(TextNodeLayoutArguments(attributedString: titleAttributedString, backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width - leftInset - 16.0 - editingOffset - rightInset - 5.0, height: CGFloat.greatestFiniteMagnitude), alignment: .natural, cutout: nil, insets: UIEdgeInsets()))
+            let (appLayout, appApply) = makeAppLayout(TextNodeLayoutArguments(attributedString: appAttributedString, backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width - leftInset - 8.0 - editingOffset - rightInset, height: CGFloat.greatestFiniteMagnitude), alignment: .natural, cutout: nil, insets: UIEdgeInsets()))
+            let (locationLayout, locationApply) = makeLocationLayout(TextNodeLayoutArguments(attributedString: locationAttributedString, backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width - leftInset - 8.0 - editingOffset - rightInset, height: CGFloat.greatestFiniteMagnitude), alignment: .natural, cutout: nil, insets: UIEdgeInsets()))
+            
+            let insets = itemListNeighborsGroupedInsets(neighbors, params)
+            let contentSize = CGSize(width: params.width, height: verticalInset * 2.0 + titleLayout.size.height + titleSpacing + appLayout.size.height + textSpacing + locationLayout.size.height)
+            let separatorHeight = UIScreenPixel
+            let separatorRightInset: CGFloat = item.systemStyle == .glass ? 16.0 : 0.0
+            
+            let layout = ListViewItemNodeLayout(contentSize: contentSize, insets: insets)
+            let layoutSize = layout.size
+            
+            if !item.enabled {
+                if currentDisabledOverlayNode == nil {
+                    currentDisabledOverlayNode = ASDisplayNode()
+                    currentDisabledOverlayNode?.backgroundColor = UIColor(white: 1.0, alpha: 0.5)
+                }
+            } else {
+                currentDisabledOverlayNode = nil
+            }
+            
+            return (layout, { [weak self] animated in
+                if let strongSelf = self {
+                    strongSelf.layoutParams = (item, params, neighbors)
+                    
+                    strongSelf.activateArea.frame = CGRect(origin: CGPoint(x: params.leftInset, y: 0.0), size: CGSize(width: params.width - params.leftInset - params.rightInset, height: layout.contentSize.height))
+                    
+                    var label = ""
+                    if item.session.isCurrent {
+                        label = item.presentationData.strings.VoiceOver_AuthSessions_CurrentSession
+                        label += ", "
+                    }
+                    label += titleAttributedString?.string ?? ""
+                    strongSelf.activateArea.accessibilityLabel = label
+                    
+                    var value = ""
+                    if let string = appAttributedString?.string {
+                        value += string
+                    }
+                    if let string = locationAttributedString?.string {
+                        if !value.isEmpty {
+                            value += "\n"
+                        }
+                        value += string
+                    }
+                    strongSelf.activateArea.accessibilityValue = value
+                    
+                    if item.enabled {
+                        strongSelf.activateArea.accessibilityTraits = []
+                    } else {
+                        strongSelf.activateArea.accessibilityTraits = .notEnabled
+                    }
+                    
+                    if let updatedIcon = updatedIcon {
+                        strongSelf.iconNode.image = updatedIcon
+                    }
+                    
+                    if let _ = updatedTheme {
+                        strongSelf.topStripeNode.backgroundColor = item.presentationData.theme.list.itemBlocksSeparatorColor
+                        strongSelf.bottomStripeNode.backgroundColor = item.presentationData.theme.list.itemBlocksSeparatorColor
+                        strongSelf.backgroundNode.backgroundColor = item.presentationData.theme.list.itemBlocksBackgroundColor
+                        strongSelf.highlightedBackgroundNode.backgroundColor = item.presentationData.theme.list.itemHighlightedBackgroundColor
+                    }
+                    
+                    let revealOffset = strongSelf.revealOffset
+                    
+                    let transition: ContainedViewLayoutTransition
+                    if animated {
+                        transition = ContainedViewLayoutTransition.animated(duration: 0.4, curve: .spring)
+                    } else {
+                        transition = .immediate
+                    }
+                    
+                    if let currentDisabledOverlayNode = currentDisabledOverlayNode {
+                        if currentDisabledOverlayNode != strongSelf.disabledOverlayNode {
+                            strongSelf.disabledOverlayNode = currentDisabledOverlayNode
+                            strongSelf.addSubnode(currentDisabledOverlayNode)
+                            currentDisabledOverlayNode.alpha = 0.0
+                            transition.updateAlpha(node: currentDisabledOverlayNode, alpha: 1.0)
+                            currentDisabledOverlayNode.frame = CGRect(origin: CGPoint(), size: CGSize(width: layout.contentSize.width, height: layout.contentSize.height - separatorHeight))
+                        } else {
+                            transition.updateFrame(node: currentDisabledOverlayNode, frame: CGRect(origin: CGPoint(), size: CGSize(width: layout.contentSize.width, height: layout.contentSize.height - separatorHeight)))
+                        }
+                    } else if let disabledOverlayNode = strongSelf.disabledOverlayNode {
+                        transition.updateAlpha(node: disabledOverlayNode, alpha: 0.0, completion: { [weak disabledOverlayNode] _ in
+                            disabledOverlayNode?.removeFromSupernode()
+                        })
+                        strongSelf.disabledOverlayNode = nil
+                    }
+                    
+                    if let editableControlSizeAndApply = editableControlSizeAndApply {
+                        let editableControlFrame = CGRect(origin: CGPoint(x: params.leftInset + revealOffset, y: 0.0), size: CGSize(width: editableControlSizeAndApply.0, height: layout.contentSize.height))
+                        if strongSelf.editableControlNode == nil {
+                            let editableControlNode = editableControlSizeAndApply.1(layout.contentSize.height)
+                            editableControlNode.tapped = {
+                                if let strongSelf = self {
+                                    strongSelf.setRevealOptionsOpened(true, animated: true)
+                                    strongSelf.revealOptionsInteractivelyOpened()
+                                }
+                            }
+                            strongSelf.editableControlNode = editableControlNode
+                            strongSelf.insertSubnode(editableControlNode, aboveSubnode: strongSelf.containerNode)
+                            editableControlNode.frame = editableControlFrame
+                            transition.animatePosition(node: editableControlNode, from: CGPoint(x: -editableControlFrame.size.width / 2.0, y: editableControlFrame.midY))
+                            editableControlNode.alpha = 0.0
+                            transition.updateAlpha(node: editableControlNode, alpha: 1.0)
+                        } else {
+                            strongSelf.editableControlNode?.frame = editableControlFrame
+                        }
+                        strongSelf.editableControlNode?.isHidden = !item.editable
+                    } else if let editableControlNode = strongSelf.editableControlNode {
+                        var editableControlFrame = editableControlNode.frame
+                        editableControlFrame.origin.x = -editableControlFrame.size.width
+                        strongSelf.editableControlNode = nil
+                        transition.updateAlpha(node: editableControlNode, alpha: 0.0)
+                        transition.updateFrame(node: editableControlNode, frame: editableControlFrame, completion: { [weak editableControlNode] _ in
+                            editableControlNode?.removeFromSupernode()
+                        })
+                    }
+                    
+                    let _ = titleApply()
+                    let _ = appApply()
+                    let _ = locationApply()
+                    
+                    if strongSelf.backgroundNode.supernode == nil {
+                        strongSelf.insertSubnode(strongSelf.backgroundNode, at: 0)
+                    }
+                    if strongSelf.topStripeNode.supernode == nil {
+                        strongSelf.insertSubnode(strongSelf.topStripeNode, at: 1)
+                    }
+                    if strongSelf.bottomStripeNode.supernode == nil {
+                        strongSelf.insertSubnode(strongSelf.bottomStripeNode, at: 2)
+                    }
+                    if strongSelf.maskNode.supernode == nil {
+                        strongSelf.addSubnode(strongSelf.maskNode)
+                    }
+                    
+                    let hasCorners = itemListHasRoundedBlockLayout(params)
+                    var hasTopCorners = false
+                    var hasBottomCorners = false
+                    switch neighbors.top {
+                        case .sameSection(false):
+                            strongSelf.topStripeNode.isHidden = true
+                        default:
+                            hasTopCorners = true
+                            strongSelf.topStripeNode.isHidden = hasCorners
+                    }
+                    let bottomStripeInset: CGFloat
+                    let bottomStripeOffset: CGFloat
+                    switch neighbors.bottom {
+                        case .sameSection(false):
+                            bottomStripeInset = leftInset + editingOffset
+                            bottomStripeOffset = -separatorHeight
+                            strongSelf.bottomStripeNode.isHidden = false
+                        default:
+                            bottomStripeInset = 0.0
+                            bottomStripeOffset = 0.0
+                            hasBottomCorners = true
+                            strongSelf.bottomStripeNode.isHidden = hasCorners
+                    }
+                    
+                    strongSelf.maskNode.image = hasCorners ? PresentationResourcesItemList.cornersImage(item.presentationData.theme, top: hasTopCorners, bottom: hasBottomCorners, glass: item.systemStyle == .glass) : nil
+                    
+                    strongSelf.backgroundNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: params.width, height: contentSize.height + min(insets.top, separatorHeight) + min(insets.bottom, separatorHeight)))
+                    strongSelf.containerNode.frame = CGRect(origin: CGPoint(), size: strongSelf.backgroundNode.frame.size)
+                    strongSelf.maskNode.frame = strongSelf.backgroundNode.frame.insetBy(dx: params.leftInset, dy: 0.0)
+                    transition.updateFrame(node: strongSelf.topStripeNode, frame: CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: layoutSize.width, height: separatorHeight)))
+                    transition.updateFrame(node: strongSelf.bottomStripeNode, frame: CGRect(origin: CGPoint(x: bottomStripeInset, y: contentSize.height + bottomStripeOffset), size: CGSize(width: layoutSize.width - bottomStripeInset - params.rightInset - separatorRightInset, height: separatorHeight)))
+                    
+                    transition.updateFrame(node: strongSelf.iconNode, frame: CGRect(origin: CGPoint(x: params.leftInset + revealOffset + editingOffset + 16.0, y: 12.0), size: CGSize(width: 30.0, height: 30.0)))
+                    transition.updateFrame(node: strongSelf.titleNode, frame: CGRect(origin: CGPoint(x: leftInset + revealOffset + editingOffset, y: verticalInset), size: titleLayout.size))
+                    transition.updateFrame(node: strongSelf.appNode, frame: CGRect(origin: CGPoint(x: leftInset + revealOffset + editingOffset, y: strongSelf.titleNode.frame.maxY + titleSpacing), size: appLayout.size))
+                    transition.updateFrame(node: strongSelf.locationNode, frame: CGRect(origin: CGPoint(x: leftInset + revealOffset + editingOffset, y: strongSelf.appNode.frame.maxY + textSpacing), size: locationLayout.size))
+                    
+                    strongSelf.highlightedBackgroundNode.frame = CGRect(origin: CGPoint(x: 0.0, y: 0.0), size: CGSize(width: params.width, height: contentSize.height + min(insets.top, separatorHeight) + min(insets.bottom, separatorHeight)))
+                    
+                    strongSelf.updateLayout(size: layout.contentSize, leftInset: params.leftInset, rightInset: params.rightInset)
+                    
+                    strongSelf.setRevealOptions((left: [], right: peerRevealOptions))
+                    strongSelf.setRevealOptionsOpened(item.revealed, animated: animated)
+                }
+            })
+        }
+    }
+    
+    override public func setHighlighted(_ highlighted: Bool, at point: CGPoint, animated: Bool) {
+        super.setHighlighted(highlighted, at: point, animated: animated)
+        
+        if highlighted && (self.layoutParams?.0.enabled ?? false) {
+            self.highlightedBackgroundNode.alpha = 1.0
+            if self.highlightedBackgroundNode.supernode == nil {
+                var anchorNode: ASDisplayNode?
+                if self.bottomStripeNode.supernode != nil {
+                    anchorNode = self.bottomStripeNode
+                } else if self.topStripeNode.supernode != nil {
+                    anchorNode = self.topStripeNode
+                } else if self.backgroundNode.supernode != nil {
+                    anchorNode = self.backgroundNode
+                }
+                if let anchorNode = anchorNode {
+                    self.insertSubnode(self.highlightedBackgroundNode, aboveSubnode: anchorNode)
+                } else {
+                    self.addSubnode(self.highlightedBackgroundNode)
+                }
+            }
+        } else {
+            if self.highlightedBackgroundNode.supernode != nil {
+                if animated {
+                    self.highlightedBackgroundNode.layer.animateAlpha(from: self.highlightedBackgroundNode.alpha, to: 0.0, duration: 0.4, completion: { [weak self] completed in
+                        if let strongSelf = self {
+                            if completed {
+                                strongSelf.highlightedBackgroundNode.removeFromSupernode()
+                            }
+                        }
+                        })
+                    self.highlightedBackgroundNode.alpha = 0.0
+                } else {
+                    self.highlightedBackgroundNode.removeFromSupernode()
+                }
+            }
+        }
+    }
+    
+    override func animateInsertion(_ currentTimestamp: Double, duration: Double, options: ListViewItemAnimationOptions) {
+        self.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.4)
+    }
+    
+    override func animateRemoved(_ currentTimestamp: Double, duration: Double) {
+        self.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.15, removeOnCompletion: false)
+    }
+    
+    override func updateRevealOffset(offset: CGFloat, transition: ContainedViewLayoutTransition) {
+        super.updateRevealOffset(offset: offset, transition: transition)
+        
+        guard let params = self.layoutParams?.1 else {
+            return
+        }
+        
+        let leftInset: CGFloat = 59.0 + params.leftInset
+        
+        let editingOffset: CGFloat
+        if let editableControlNode = self.editableControlNode {
+            editingOffset = editableControlNode.bounds.size.width
+            var editableControlFrame = editableControlNode.frame
+            editableControlFrame.origin.x = params.leftInset + offset
+            transition.updateFrame(node: editableControlNode, frame: editableControlFrame)
+        } else {
+            editingOffset = 0.0
+        }
+        
+        transition.updateFrame(node: self.iconNode, frame: CGRect(origin: CGPoint(x: params.leftInset + self.revealOffset + editingOffset + 16.0, y: self.iconNode.frame.minY), size: self.iconNode.bounds.size))
+        transition.updateFrame(node: self.titleNode, frame: CGRect(origin: CGPoint(x: leftInset + revealOffset + editingOffset, y: self.titleNode.frame.minY), size: self.titleNode.bounds.size))
+        transition.updateFrame(node: self.appNode, frame: CGRect(origin: CGPoint(x: leftInset + revealOffset + editingOffset, y: self.appNode.frame.minY), size: self.appNode.bounds.size))
+        transition.updateFrame(node: self.locationNode, frame: CGRect(origin: CGPoint(x: leftInset + revealOffset + editingOffset, y: self.locationNode.frame.minY), size: self.locationNode.bounds.size))
+    }
+    
+    override func revealOptionsInteractivelyOpened() {
+        if let (item, _, _) = self.layoutParams {
+            item.setSessionIdWithRevealedOptions(item.session.hash, nil)
+        }
+    }
+    
+    override func revealOptionsInteractivelyClosed() {
+        if let (item, _, _) = self.layoutParams {
+            item.setSessionIdWithRevealedOptions(nil, item.session.hash)
+        }
+    }
+    
+    override func revealOptionSelected(_ option: ItemListRevealOption, animated: Bool) {
+        self.setRevealOptionsOpened(false, animated: true)
+        self.revealOptionsInteractivelyClosed()
+        
+        if let (item, _, _) = self.layoutParams {
+            item.removeSession(item.session.hash)
+        }
+    }
+}

submodules/SettingsUI/Sources/Privacy and Security/Recent Sessions/ItemListWebsiteItem.swift

@@ -0,0 +1,552 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import Postbox
+import TelegramCore
+import TelegramPresentationData
+import TelegramUIPreferences
+import ItemListUI
+import PresentationDataUtils
+import AvatarNode
+import TelegramStringFormatting
+import LocalizedPeerData
+import AccountContext
+
+struct ItemListWebsiteItemEditing: Equatable {
+    let editing: Bool
+    let revealed: Bool
+    
+    static func ==(lhs: ItemListWebsiteItemEditing, rhs: ItemListWebsiteItemEditing) -> Bool {
+        if lhs.editing != rhs.editing {
+            return false
+        }
+        if lhs.revealed != rhs.revealed {
+            return false
+        }
+        return true
+    }
+}
+
+final class ItemListWebsiteItem: ListViewItem, ItemListItem {
+    let context: AccountContext
+    let presentationData: ItemListPresentationData
+    let systemStyle: ItemListSystemStyle
+    let dateTimeFormat: PresentationDateTimeFormat
+    let nameDisplayOrder: PresentationPersonNameOrder
+    let website: WebAuthorization
+    let peer: Peer?
+    let enabled: Bool
+    let editing: Bool
+    let revealed: Bool
+    let sectionId: ItemListSectionId
+    let setSessionIdWithRevealedOptions: (Int64?, Int64?) -> Void
+    let removeSession: (Int64) -> Void
+    let action: (() -> Void)?
+    
+    init(context: AccountContext, presentationData: ItemListPresentationData, systemStyle: ItemListSystemStyle, dateTimeFormat: PresentationDateTimeFormat, nameDisplayOrder: PresentationPersonNameOrder, website: WebAuthorization, peer: Peer?, enabled: Bool, editing: Bool, revealed: Bool, sectionId: ItemListSectionId, setSessionIdWithRevealedOptions: @escaping (Int64?, Int64?) -> Void, removeSession: @escaping (Int64) -> Void, action: (() -> Void)?) {
+        self.context = context
+        self.presentationData = presentationData
+        self.systemStyle = systemStyle
+        self.dateTimeFormat = dateTimeFormat
+        self.nameDisplayOrder = nameDisplayOrder
+        self.website = website
+        self.peer = peer
+        self.enabled = enabled
+        self.editing = editing
+        self.revealed = revealed
+        self.sectionId = sectionId
+        self.setSessionIdWithRevealedOptions = setSessionIdWithRevealedOptions
+        self.removeSession = removeSession
+        self.action = action
+    }
+    
+    func nodeConfiguredForParams(async: @escaping (@escaping () -> Void) -> Void, params: ListViewItemLayoutParams, synchronousLoads: Bool, previousItem: ListViewItem?, nextItem: ListViewItem?, completion: @escaping (ListViewItemNode, @escaping () -> (Signal<Void, NoError>?, (ListViewItemApply) -> Void)) -> Void) {
+        async {
+            let node = ItemListWebsiteItemNode()
+            let (layout, apply) = node.asyncLayout()(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem))
+            
+            node.contentSize = layout.contentSize
+            node.insets = layout.insets
+            
+            Queue.mainQueue().async {
+                completion(node, {
+                    return (nil, { _ in apply(false) })
+                })
+            }
+        }
+    }
+    
+    func updateNode(async: @escaping (@escaping () -> Void) -> Void, node: @escaping () -> ListViewItemNode, params: ListViewItemLayoutParams, previousItem: ListViewItem?, nextItem: ListViewItem?, animation: ListViewItemUpdateAnimation, completion: @escaping (ListViewItemNodeLayout, @escaping (ListViewItemApply) -> Void) -> Void) {
+        Queue.mainQueue().async {
+            if let nodeValue = node() as? ItemListWebsiteItemNode {
+                let makeLayout = nodeValue.asyncLayout()
+                
+                var animated = true
+                if case .None = animation {
+                    animated = false
+                }
+                
+                async {
+                    let (layout, apply) = makeLayout(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem))
+                    Queue.mainQueue().async {
+                        completion(layout, { _ in
+                            apply(animated)
+                        })
+                    }
+                }
+            }
+        }
+    }
+    
+    public var selectable: Bool = true
+    public func selected(listView: ListView){
+        listView.clearHighlightAnimated(true)
+        
+        if self.enabled {
+            self.action?()
+        }
+    }
+}
+
+private let avatarFont = avatarPlaceholderFont(size: 11.0)
+
+private func trimmedLocationName(_ session: WebAuthorization) -> String {
+    var country = session.region
+    country = country.replacingOccurrences(of: "United Arab Emirates", with: "UAE")
+    return country
+}
+
+
+class ItemListWebsiteItemNode: ItemListRevealOptionsItemNode {
+    private let backgroundNode: ASDisplayNode
+    private let topStripeNode: ASDisplayNode
+    private let bottomStripeNode: ASDisplayNode
+    private let highlightedBackgroundNode: ASDisplayNode
+    private var disabledOverlayNode: ASDisplayNode?
+    private let maskNode: ASImageNode
+    
+    let avatarNode: AvatarNode
+    private let titleNode: TextNode
+    private let appNode: TextNode
+    private let locationNode: TextNode
+    
+    private let containerNode: ASDisplayNode
+    override var controlsContainer: ASDisplayNode {
+        return self.containerNode
+    }
+    
+    private let activateArea: AccessibilityAreaNode
+    
+    private var layoutParams: (ItemListWebsiteItem, ListViewItemLayoutParams, ItemListNeighbors)?
+    
+    private var editableControlNode: ItemListEditableControlNode?
+    
+    override public var canBeSelected: Bool {
+        if let item = self.layoutParams?.0, let _ = item.action {
+            return true
+        } else {
+            return false
+        }
+    }
+    
+    init() {
+        self.backgroundNode = ASDisplayNode()
+        self.backgroundNode.isLayerBacked = true
+        
+        self.topStripeNode = ASDisplayNode()
+        self.topStripeNode.isLayerBacked = true
+        
+        self.bottomStripeNode = ASDisplayNode()
+        self.bottomStripeNode.isLayerBacked = true
+                
+        self.maskNode = ASImageNode()
+        self.maskNode.isUserInteractionEnabled = false
+        
+        self.containerNode = ASDisplayNode()
+        
+        self.avatarNode = AvatarNode(font: avatarFont)
+        self.avatarNode.cornerRadius = 7.0
+        self.avatarNode.clipsToBounds = true
+        
+        self.titleNode = TextNode()
+        self.titleNode.isUserInteractionEnabled = false
+        self.titleNode.contentMode = .left
+        self.titleNode.contentsScale = UIScreen.main.scale
+        
+        self.appNode = TextNode()
+        self.appNode.isUserInteractionEnabled = false
+        self.appNode.contentMode = .left
+        self.appNode.contentsScale = UIScreen.main.scale
+        
+        self.locationNode = TextNode()
+        self.locationNode.isUserInteractionEnabled = false
+        self.locationNode.contentMode = .left
+        self.locationNode.contentsScale = UIScreen.main.scale
+        
+        self.highlightedBackgroundNode = ASDisplayNode()
+        self.highlightedBackgroundNode.isLayerBacked = true
+        
+        self.activateArea = AccessibilityAreaNode()
+        
+        super.init(layerBacked: false, dynamicBounce: false, rotated: false, seeThrough: false)
+        
+        self.addSubnode(self.containerNode)
+        self.containerNode.addSubnode(self.avatarNode)
+        self.containerNode.addSubnode(self.titleNode)
+        self.containerNode.addSubnode(self.appNode)
+        self.containerNode.addSubnode(self.locationNode)
+        
+        self.addSubnode(self.activateArea)
+    }
+    
+    func asyncLayout() -> (_ item: ItemListWebsiteItem, _ params: ListViewItemLayoutParams, _ neighbors: ItemListNeighbors) -> (ListViewItemNodeLayout, (Bool) -> Void) {
+        let makeTitleLayout = TextNode.asyncLayout(self.titleNode)
+        let makeAppLayout = TextNode.asyncLayout(self.appNode)
+        let makeLocationLayout = TextNode.asyncLayout(self.locationNode)
+        let editableControlLayout = ItemListEditableControlNode.asyncLayout(self.editableControlNode)
+        
+        var currentDisabledOverlayNode = self.disabledOverlayNode
+        
+        let currentItem = self.layoutParams?.0
+        
+        return { item, params, neighbors in
+            var updatedTheme: PresentationTheme?
+            
+            let titleFont = Font.medium(floor(item.presentationData.fontSize.itemListBaseFontSize * 16.0 / 17.0))
+            let textFont = Font.regular(floor(item.presentationData.fontSize.itemListBaseFontSize * 14.0 / 17.0))
+            
+            if currentItem?.presentationData !== item.presentationData.theme {
+                updatedTheme = item.presentationData.theme
+            }
+            
+            var titleAttributedString: NSAttributedString?
+            var appAttributedString: NSAttributedString?
+            var locationAttributedString: NSAttributedString?
+            
+            let peerRevealOptions = [ItemListRevealOption(key: 0, title: item.presentationData.strings.AuthSessions_LogOut, icon: .none, color: item.presentationData.theme.list.itemDisclosureActions.destructive.fillColor, textColor: item.presentationData.theme.list.itemDisclosureActions.destructive.foregroundColor)]
+            
+            let rightInset: CGFloat = params.rightInset
+            
+            if let user = item.peer as? TelegramUser {
+                titleAttributedString = NSAttributedString(string: EnginePeer(user).displayTitle(strings: item.presentationData.strings, displayOrder: item.nameDisplayOrder), font: titleFont, textColor: item.presentationData.theme.list.itemPrimaryTextColor)
+            }
+            
+            var appString = ""
+            if !item.website.domain.isEmpty {
+                appString = item.website.domain
+            }
+            
+            if !item.website.browser.isEmpty {
+                if !appString.isEmpty {
+                    appString += ", "
+                }
+                appString += item.website.browser
+            }
+            
+            if !item.website.platform.isEmpty {
+                if !appString.isEmpty {
+                    appString += ", "
+                }
+                appString += item.website.platform
+            }
+            
+            appAttributedString = NSAttributedString(string: appString, font: textFont, textColor: item.presentationData.theme.list.itemPrimaryTextColor)
+            
+            let timestamp = Int32(CFAbsoluteTimeGetCurrent() + NSTimeIntervalSince1970)
+            let label = stringForRelativeActivityTimestamp(strings: item.presentationData.strings, dateTimeFormat: item.dateTimeFormat, relativeTimestamp: item.website.dateActive, relativeTo: timestamp)
+            
+            locationAttributedString = NSAttributedString(string: "\(trimmedLocationName(item.website)) • \(label)", font: textFont, textColor: item.presentationData.theme.list.itemSecondaryTextColor)
+            
+            let leftInset: CGFloat = 59.0 + params.leftInset
+            
+            var editableControlSizeAndApply: (CGFloat, (CGFloat) -> ItemListEditableControlNode)?
+            
+            let editingOffset: CGFloat
+            if item.editing {
+                let sizeAndApply = editableControlLayout(item.presentationData.theme, false)
+                editableControlSizeAndApply = sizeAndApply
+                editingOffset = sizeAndApply.0
+            } else {
+                editingOffset = 0.0
+            }
+            
+            let (titleLayout, titleApply) = makeTitleLayout(TextNodeLayoutArguments(attributedString: titleAttributedString, backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width - leftInset - 8.0 - editingOffset - rightInset - 5.0 - 20.0, height: CGFloat.greatestFiniteMagnitude), alignment: .natural, cutout: nil, insets: UIEdgeInsets()))
+            let (appLayout, appApply) = makeAppLayout(TextNodeLayoutArguments(attributedString: appAttributedString, backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width - leftInset - 8.0 - editingOffset - rightInset, height: CGFloat.greatestFiniteMagnitude), alignment: .natural, cutout: nil, insets: UIEdgeInsets()))
+            let (locationLayout, locationApply) = makeLocationLayout(TextNodeLayoutArguments(attributedString: locationAttributedString, backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width - leftInset - 8.0 - editingOffset - rightInset, height: CGFloat.greatestFiniteMagnitude), alignment: .natural, cutout: nil, insets: UIEdgeInsets()))
+            
+            var verticalInset: CGFloat = 0.0
+            if case .glass = item.systemStyle {
+                verticalInset = 4.0
+            }
+            
+            let insets = itemListNeighborsGroupedInsets(neighbors, params)
+            let contentSize = CGSize(width: params.width, height: 75.0 + verticalInset * 2.0)
+            let separatorHeight = UIScreenPixel
+            let separatorRightInset: CGFloat = item.systemStyle == .glass ? 16.0 : 0.0
+            
+            let layout = ListViewItemNodeLayout(contentSize: contentSize, insets: insets)
+            let layoutSize = layout.size
+            
+            if !item.enabled {
+                if currentDisabledOverlayNode == nil {
+                    currentDisabledOverlayNode = ASDisplayNode()
+                    currentDisabledOverlayNode?.backgroundColor = UIColor(white: 1.0, alpha: 0.5)
+                }
+            } else {
+                currentDisabledOverlayNode = nil
+            }
+            
+            return (layout, { [weak self] animated in
+                if let strongSelf = self {
+                    strongSelf.layoutParams = (item, params, neighbors)
+                    
+                    strongSelf.activateArea.frame = CGRect(origin: CGPoint(x: params.leftInset, y: 0.0), size: CGSize(width: params.width - params.leftInset - params.rightInset, height: layout.contentSize.height))
+                    
+                    strongSelf.activateArea.accessibilityLabel = titleAttributedString?.string ?? ""
+                    
+                    var value = ""
+                    if let string = appAttributedString?.string {
+                        value += string
+                    }
+                    if let string = locationAttributedString?.string {
+                        if !value.isEmpty {
+                            value += "\n"
+                        }
+                        value += string
+                    }
+                    strongSelf.activateArea.accessibilityValue = value
+                    
+                    if item.enabled {
+                        strongSelf.activateArea.accessibilityTraits = []
+                    } else {
+                        strongSelf.activateArea.accessibilityTraits = .notEnabled
+                    }
+                    
+                    if let _ = updatedTheme {
+                        strongSelf.topStripeNode.backgroundColor = item.presentationData.theme.list.itemBlocksSeparatorColor
+                        strongSelf.bottomStripeNode.backgroundColor = item.presentationData.theme.list.itemBlocksSeparatorColor
+                        strongSelf.backgroundNode.backgroundColor = item.presentationData.theme.list.itemBlocksBackgroundColor
+                        strongSelf.highlightedBackgroundNode.backgroundColor = item.presentationData.theme.list.itemHighlightedBackgroundColor
+                    }
+                    
+                    if let peer = item.peer {
+                        strongSelf.avatarNode.setPeer(context: item.context, theme: item.presentationData.theme, peer: EnginePeer(peer), authorOfMessage: nil, overrideImage: nil, emptyColor: nil, clipStyle: .none, synchronousLoad: false)
+                    }
+                    
+                    let revealOffset = strongSelf.revealOffset
+                    
+                    let transition: ContainedViewLayoutTransition
+                    if animated {
+                        transition = ContainedViewLayoutTransition.animated(duration: 0.4, curve: .spring)
+                    } else {
+                        transition = .immediate
+                    }
+                    
+                    if let currentDisabledOverlayNode = currentDisabledOverlayNode {
+                        if currentDisabledOverlayNode != strongSelf.disabledOverlayNode {
+                            strongSelf.disabledOverlayNode = currentDisabledOverlayNode
+                            strongSelf.addSubnode(currentDisabledOverlayNode)
+                            currentDisabledOverlayNode.alpha = 0.0
+                            transition.updateAlpha(node: currentDisabledOverlayNode, alpha: 1.0)
+                            currentDisabledOverlayNode.frame = CGRect(origin: CGPoint(), size: CGSize(width: layout.contentSize.width, height: layout.contentSize.height - separatorHeight))
+                        } else {
+                            transition.updateFrame(node: currentDisabledOverlayNode, frame: CGRect(origin: CGPoint(), size: CGSize(width: layout.contentSize.width, height: layout.contentSize.height - separatorHeight)))
+                        }
+                    } else if let disabledOverlayNode = strongSelf.disabledOverlayNode {
+                        transition.updateAlpha(node: disabledOverlayNode, alpha: 0.0, completion: { [weak disabledOverlayNode] _ in
+                            disabledOverlayNode?.removeFromSupernode()
+                        })
+                        strongSelf.disabledOverlayNode = nil
+                    }
+                    
+                    if let editableControlSizeAndApply = editableControlSizeAndApply {
+                        let editableControlFrame = CGRect(origin: CGPoint(x: params.leftInset + revealOffset, y: 0.0), size: CGSize(width: editableControlSizeAndApply.0, height: layout.contentSize.height))
+                        if strongSelf.editableControlNode == nil {
+                            let editableControlNode = editableControlSizeAndApply.1(layout.contentSize.height)
+                            editableControlNode.tapped = {
+                                if let strongSelf = self {
+                                    strongSelf.setRevealOptionsOpened(true, animated: true)
+                                    strongSelf.revealOptionsInteractivelyOpened()
+                                }
+                            }
+                            strongSelf.editableControlNode = editableControlNode
+                            strongSelf.insertSubnode(editableControlNode, aboveSubnode: strongSelf.containerNode)
+                            editableControlNode.frame = editableControlFrame
+                            transition.animatePosition(node: editableControlNode, from: CGPoint(x: -editableControlFrame.size.width / 2.0, y: editableControlFrame.midY))
+                            editableControlNode.alpha = 0.0
+                            transition.updateAlpha(node: editableControlNode, alpha: 1.0)
+                        } else {
+                            strongSelf.editableControlNode?.frame = editableControlFrame
+                        }
+                        strongSelf.editableControlNode?.isHidden = false
+                    } else if let editableControlNode = strongSelf.editableControlNode {
+                        var editableControlFrame = editableControlNode.frame
+                        editableControlFrame.origin.x = -editableControlFrame.size.width
+                        strongSelf.editableControlNode = nil
+                        transition.updateAlpha(node: editableControlNode, alpha: 0.0)
+                        transition.updateFrame(node: editableControlNode, frame: editableControlFrame, completion: { [weak editableControlNode] _ in
+                            editableControlNode?.removeFromSupernode()
+                        })
+                    }
+                    
+                    let _ = titleApply()
+                    let _ = appApply()
+                    let _ = locationApply()
+                    
+                    if strongSelf.backgroundNode.supernode == nil {
+                        strongSelf.insertSubnode(strongSelf.backgroundNode, at: 0)
+                    }
+                    if strongSelf.topStripeNode.supernode == nil {
+                        strongSelf.insertSubnode(strongSelf.topStripeNode, at: 1)
+                    }
+                    if strongSelf.bottomStripeNode.supernode == nil {
+                        strongSelf.insertSubnode(strongSelf.bottomStripeNode, at: 2)
+                    }
+                    if strongSelf.maskNode.supernode == nil {
+                        strongSelf.addSubnode(strongSelf.maskNode)
+                    }
+                    
+                    let hasCorners = itemListHasRoundedBlockLayout(params)
+                    var hasTopCorners = false
+                    var hasBottomCorners = false
+                    switch neighbors.top {
+                        case .sameSection(false):
+                            strongSelf.topStripeNode.isHidden = true
+                        default:
+                            hasTopCorners = true
+                            strongSelf.topStripeNode.isHidden = hasCorners
+                    }
+                    let bottomStripeInset: CGFloat
+                    let bottomStripeOffset: CGFloat
+                    switch neighbors.bottom {
+                        case .sameSection(false):
+                            bottomStripeInset = leftInset + editingOffset
+                            bottomStripeOffset = -separatorHeight
+                            strongSelf.bottomStripeNode.isHidden = false
+                        default:
+                            bottomStripeInset = 0.0
+                            bottomStripeOffset = 0.0
+                            hasBottomCorners = true
+                            strongSelf.bottomStripeNode.isHidden = hasCorners
+                    }
+                    
+                    strongSelf.maskNode.image = hasCorners ? PresentationResourcesItemList.cornersImage(item.presentationData.theme, top: hasTopCorners, bottom: hasBottomCorners, glass: item.systemStyle == .glass) : nil
+                    
+                    strongSelf.backgroundNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: params.width, height: contentSize.height + min(insets.top, separatorHeight) + min(insets.bottom, separatorHeight)))
+                    strongSelf.containerNode.frame = CGRect(origin: CGPoint(), size: strongSelf.backgroundNode.frame.size)
+                    strongSelf.maskNode.frame = strongSelf.backgroundNode.frame.insetBy(dx: params.leftInset, dy: 0.0)
+                    transition.updateFrame(node: strongSelf.topStripeNode, frame: CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: layoutSize.width, height: separatorHeight)))
+                    transition.updateFrame(node: strongSelf.bottomStripeNode, frame: CGRect(origin: CGPoint(x: bottomStripeInset, y: contentSize.height + bottomStripeOffset), size: CGSize(width: layoutSize.width - bottomStripeInset - params.rightInset - separatorRightInset, height: separatorHeight)))
+                    
+                    
+                    transition.updateFrame(node: strongSelf.avatarNode, frame: CGRect(origin: CGPoint(x: params.leftInset + revealOffset + editingOffset + 16.0, y: verticalInset + 12.0), size: CGSize(width: 30.0, height: 30.0)))
+                    
+                    transition.updateFrame(node: strongSelf.titleNode, frame: CGRect(origin: CGPoint(x: leftInset + revealOffset + editingOffset, y: verticalInset + 10.0), size: titleLayout.size))
+                    transition.updateFrame(node: strongSelf.appNode, frame: CGRect(origin: CGPoint(x: leftInset + revealOffset + editingOffset, y: verticalInset + 30.0), size: appLayout.size))
+                    transition.updateFrame(node: strongSelf.locationNode, frame: CGRect(origin: CGPoint(x: leftInset + revealOffset + editingOffset, y: verticalInset + 50.0), size: locationLayout.size))
+                    
+                    strongSelf.highlightedBackgroundNode.frame = CGRect(origin: CGPoint(x: 0.0, y: 0.0), size: CGSize(width: params.width, height: contentSize.height + min(insets.top, separatorHeight) + min(insets.bottom, separatorHeight)))
+                    
+                    strongSelf.updateLayout(size: layout.contentSize, leftInset: params.leftInset, rightInset: params.rightInset)
+                    
+                    strongSelf.setRevealOptions((left: [], right: peerRevealOptions))
+                    strongSelf.setRevealOptionsOpened(item.revealed, animated: animated)
+                }
+            })
+        }
+    }
+    
+    override public func setHighlighted(_ highlighted: Bool, at point: CGPoint, animated: Bool) {
+        super.setHighlighted(highlighted, at: point, animated: animated)
+        
+        if highlighted && (self.layoutParams?.0.enabled ?? false) {
+            self.highlightedBackgroundNode.alpha = 1.0
+            if self.highlightedBackgroundNode.supernode == nil {
+                var anchorNode: ASDisplayNode?
+                if self.bottomStripeNode.supernode != nil {
+                    anchorNode = self.bottomStripeNode
+                } else if self.topStripeNode.supernode != nil {
+                    anchorNode = self.topStripeNode
+                } else if self.backgroundNode.supernode != nil {
+                    anchorNode = self.backgroundNode
+                }
+                if let anchorNode = anchorNode {
+                    self.insertSubnode(self.highlightedBackgroundNode, aboveSubnode: anchorNode)
+                } else {
+                    self.addSubnode(self.highlightedBackgroundNode)
+                }
+            }
+        } else {
+            if self.highlightedBackgroundNode.supernode != nil {
+                if animated {
+                    self.highlightedBackgroundNode.layer.animateAlpha(from: self.highlightedBackgroundNode.alpha, to: 0.0, duration: 0.4, completion: { [weak self] completed in
+                        if let strongSelf = self {
+                            if completed {
+                                strongSelf.highlightedBackgroundNode.removeFromSupernode()
+                            }
+                        }
+                        })
+                    self.highlightedBackgroundNode.alpha = 0.0
+                } else {
+                    self.highlightedBackgroundNode.removeFromSupernode()
+                }
+            }
+        }
+    }
+    
+    override func animateInsertion(_ currentTimestamp: Double, duration: Double, options: ListViewItemAnimationOptions) {
+        self.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.4)
+    }
+    
+    override func animateRemoved(_ currentTimestamp: Double, duration: Double) {
+        self.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.15, removeOnCompletion: false)
+    }
+    
+    override func updateRevealOffset(offset: CGFloat, transition: ContainedViewLayoutTransition) {
+        super.updateRevealOffset(offset: offset, transition: transition)
+        
+        guard let params = self.layoutParams?.1 else {
+            return
+        }
+        
+        let leftInset: CGFloat = 59.0 + params.leftInset
+        
+        let editingOffset: CGFloat
+        if let editableControlNode = self.editableControlNode {
+            editingOffset = editableControlNode.bounds.size.width
+            var editableControlFrame = editableControlNode.frame
+            editableControlFrame.origin.x = params.leftInset + offset
+            transition.updateFrame(node: editableControlNode, frame: editableControlFrame)
+        } else {
+            editingOffset = 0.0
+        }
+        
+        transition.updateFrame(node: self.avatarNode, frame: CGRect(origin: CGPoint(x: params.leftInset + self.revealOffset + editingOffset + 16.0, y: self.avatarNode.frame.minY), size: self.avatarNode.bounds.size))
+        transition.updateFrame(node: self.titleNode, frame: CGRect(origin: CGPoint(x: leftInset + self.revealOffset + editingOffset, y: self.titleNode.frame.minY), size: self.titleNode.bounds.size))
+        transition.updateFrame(node: self.appNode, frame: CGRect(origin: CGPoint(x: leftInset + self.revealOffset + editingOffset, y: self.appNode.frame.minY), size: self.appNode.bounds.size))
+        transition.updateFrame(node: self.locationNode, frame: CGRect(origin: CGPoint(x: leftInset + self.revealOffset + editingOffset, y: self.locationNode.frame.minY), size: self.locationNode.bounds.size))
+    }
+    
+    override func revealOptionsInteractivelyOpened() {
+        if let (item, _, _) = self.layoutParams {
+            item.setSessionIdWithRevealedOptions(item.website.hash, nil)
+        }
+    }
+    
+    override func revealOptionsInteractivelyClosed() {
+        if let (item, _, _) = self.layoutParams {
+            item.setSessionIdWithRevealedOptions(nil, item.website.hash)
+        }
+    }
+    
+    override func revealOptionSelected(_ option: ItemListRevealOption, animated: Bool) {
+        self.setRevealOptionsOpened(false, animated: true)
+        self.revealOptionsInteractivelyClosed()
+        
+        if let (item, _, _) = self.layoutParams {
+            item.removeSession(item.website.hash)
+        }
+    }
+}

submodules/SettingsUI/Sources/Privacy and Security/Recent Sessions/RecentSessionsController.swift

@@ -0,0 +1,895 @@
+import Foundation
+import UIKit
+import Display
+import SwiftSignalKit
+import Postbox
+import TelegramCore
+import TelegramPresentationData
+import TelegramUIPreferences
+import ItemListUI
+import PresentationDataUtils
+import AccountContext
+import ItemListPeerActionItem
+import DeviceAccess
+import QrCodeUI
+
+private final class RecentSessionsControllerArguments {
+    let context: AccountContext
+    
+    let setSessionIdWithRevealedOptions: (Int64?, Int64?) -> Void
+    let removeSession: (Int64) -> Void
+    let terminateOtherSessions: () -> Void
+    
+    let openSession: (RecentAccountSession) -> Void
+    let openWebSession: (WebAuthorization, Peer?) -> Void
+    
+    let removeWebSession: (Int64) -> Void
+    let terminateAllWebSessions: () -> Void
+
+    let addDevice: () -> Void
+    
+    let openOtherAppsUrl: () -> Void
+    let setupAuthorizationTTL: () -> Void
+    
+    let openDesktopLink: () -> Void
+    let openWebLink: () -> Void
+    
+    init(context: AccountContext, setSessionIdWithRevealedOptions: @escaping (Int64?, Int64?) -> Void, removeSession: @escaping (Int64) -> Void, terminateOtherSessions: @escaping () -> Void, openSession: @escaping (RecentAccountSession) -> Void, openWebSession: @escaping (WebAuthorization, Peer?) -> Void, removeWebSession: @escaping (Int64) -> Void, terminateAllWebSessions: @escaping () -> Void, addDevice: @escaping () -> Void, openOtherAppsUrl: @escaping () -> Void, setupAuthorizationTTL: @escaping () -> Void, openDesktopLink: @escaping () -> Void, openWebLink: @escaping () -> Void) {
+        self.context = context
+        self.setSessionIdWithRevealedOptions = setSessionIdWithRevealedOptions
+        self.removeSession = removeSession
+        self.terminateOtherSessions = terminateOtherSessions
+        
+        self.openSession = openSession
+        self.openWebSession = openWebSession
+        
+        self.removeWebSession = removeWebSession
+        self.terminateAllWebSessions = terminateAllWebSessions
+        
+        self.addDevice = addDevice
+        
+        self.openOtherAppsUrl = openOtherAppsUrl
+        
+        self.setupAuthorizationTTL = setupAuthorizationTTL
+        
+        self.openDesktopLink = openDesktopLink
+        self.openWebLink = openWebLink
+    }
+}
+
+private enum RecentSessionsMode: Int {
+    case sessions
+    case websites
+}
+
+private enum RecentSessionsSection: Int32 {
+    case header
+    case currentSession
+    case pendingSessions
+    case otherSessions
+    case ttl
+}
+
+private enum RecentSessionsEntryStableId: Hashable {
+    case session(Int64)
+    case index(Int32)
+    case devicesInfo
+    case ttl(Int32)
+}
+
+private struct SortIndex: Comparable {
+    var section: Int
+    var item: Int
+
+    static func <(lhs: SortIndex, rhs: SortIndex) -> Bool {
+        if lhs.section != rhs.section {
+            return lhs.section < rhs.section
+        }
+        return lhs.item < rhs.item
+    }
+}
+
+private enum RecentSessionsEntry: ItemListNodeEntry {
+    case header(SortIndex, String)
+    case currentSessionHeader(SortIndex, String)
+    case currentSession(SortIndex, PresentationStrings, PresentationDateTimeFormat, RecentAccountSession)
+    case terminateOtherSessions(SortIndex, String)
+    case terminateAllWebSessions(SortIndex, String)
+    case currentAddDevice(SortIndex, String)
+    case currentSessionInfo(SortIndex, String)
+    case pendingSessionsHeader(SortIndex, String)
+    case pendingSession(index: Int32, sortIndex: SortIndex, strings: PresentationStrings, dateTimeFormat: PresentationDateTimeFormat, session: RecentAccountSession, enabled: Bool, editing: Bool, revealed: Bool)
+    case pendingSessionsInfo(SortIndex, String)
+    case otherSessionsHeader(SortIndex, String)
+    case addDevice(SortIndex, String)
+    case session(index: Int32, sortIndex: SortIndex, strings: PresentationStrings, dateTimeFormat: PresentationDateTimeFormat, session: RecentAccountSession, enabled: Bool, editing: Bool, revealed: Bool)
+    case website(index: Int32, sortIndex: SortIndex, strings: PresentationStrings, dateTimeFormat: PresentationDateTimeFormat, nameDisplayOrder: PresentationPersonNameOrder, website: WebAuthorization, peer: Peer?, enabled: Bool, editing: Bool, revealed: Bool)
+    case devicesInfo(SortIndex, String)
+    case ttlHeader(SortIndex, String)
+    case ttlTimeout(SortIndex, String, String)
+    
+    var section: ItemListSectionId {
+        switch self {
+            case .header:
+                return RecentSessionsSection.header.rawValue
+            case .currentSessionHeader, .currentSession, .terminateOtherSessions, .terminateAllWebSessions, .currentAddDevice, .currentSessionInfo:
+                return RecentSessionsSection.currentSession.rawValue
+            case .pendingSessionsHeader, .pendingSession, .pendingSessionsInfo:
+                return RecentSessionsSection.pendingSessions.rawValue
+            case .otherSessionsHeader, .addDevice, .session, .website, .devicesInfo:
+                return RecentSessionsSection.otherSessions.rawValue
+            case .ttlHeader, .ttlTimeout:
+                return RecentSessionsSection.ttl.rawValue
+        }
+    }
+    
+    var stableId: RecentSessionsEntryStableId {
+        switch self {
+        case .header:
+            return .index(0)
+        case .currentSessionHeader:
+            return .index(1)
+        case .currentSession:
+            return .index(2)
+        case .terminateOtherSessions:
+            return .index(3)
+        case .terminateAllWebSessions:
+            return .index(4)
+        case .currentAddDevice:
+            return .index(5)
+        case .currentSessionInfo:
+            return .index(6)
+        case .pendingSessionsHeader:
+            return .index(7)
+        case let .pendingSession(_, _, _, _, session, _, _, _):
+            return .session(session.hash)
+        case .pendingSessionsInfo:
+            return .index(8)
+        case .otherSessionsHeader:
+            return .index(9)
+        case .addDevice:
+            return .index(10)
+        case let .session(_, _, _, _, session, _, _, _):
+            return .session(session.hash)
+        case let .website(_, _, _, _, _, website, _, _, _, _):
+            return .session(website.hash)
+        case .devicesInfo:
+            return .devicesInfo
+        case .ttlHeader:
+            return .index(11)
+        case .ttlTimeout:
+            return .index(12)
+        }
+    }
+
+    var sortIndex: SortIndex {
+        switch self {
+        case let .header(index, _):
+            return index
+        case let .currentSessionHeader(index, _):
+            return index
+        case let .currentSession(index, _, _, _):
+            return index
+        case let .terminateOtherSessions(index, _):
+            return index
+        case let .terminateAllWebSessions(index, _):
+            return index
+        case let .currentAddDevice(index, _):
+            return index
+        case let .currentSessionInfo(index, _):
+            return index
+        case let .pendingSessionsHeader(index, _):
+            return index
+        case let .pendingSession(_, index, _, _, _, _, _, _):
+            return index
+        case let .pendingSessionsInfo(index, _):
+            return index
+        case let .otherSessionsHeader(index, _):
+            return index
+        case let .addDevice(index, _):
+            return index
+        case let .session(_, index, _, _, _, _, _, _):
+            return index
+        case let .website(_, index, _, _, _, _, _, _, _, _):
+            return index
+        case let .devicesInfo(index, _):
+            return index
+        case let .ttlHeader(index, _):
+            return index
+        case let .ttlTimeout(index, _, _):
+            return index
+        }
+    }
+    
+    static func ==(lhs: RecentSessionsEntry, rhs: RecentSessionsEntry) -> Bool {
+        switch lhs {
+        case let .header(lhsSortIndex, lhsText):
+            if case let .header(rhsSortIndex, rhsText) = rhs, lhsSortIndex == rhsSortIndex, lhsText == rhsText {
+                return true
+            } else {
+                return false
+            }
+        case let .currentSessionHeader(lhsSortIndex, lhsText):
+            if case let .currentSessionHeader(rhsSortIndex, rhsText) = rhs, lhsSortIndex == rhsSortIndex, lhsText == rhsText {
+                return true
+            } else {
+                return false
+            }
+        case let .terminateOtherSessions(lhsSortIndex, lhsText):
+            if case let .terminateOtherSessions(rhsSortIndex, rhsText) = rhs, lhsSortIndex == rhsSortIndex, lhsText == rhsText {
+                return true
+            } else {
+                return false
+            }
+        case let .terminateAllWebSessions(lhsSortIndex, lhsText):
+            if case let .terminateAllWebSessions(rhsSortIndex, rhsText) = rhs, lhsSortIndex == rhsSortIndex, lhsText == rhsText {
+                return true
+            } else {
+                return false
+            }
+        case let .currentAddDevice(lhsSortIndex, lhsText):
+            if case let .currentAddDevice(rhsSortIndex, rhsText) = rhs, lhsSortIndex == rhsSortIndex, lhsText == rhsText {
+                return true
+            } else {
+                return false
+            }
+        case let .currentSessionInfo(lhsSortIndex, lhsText):
+            if case let .currentSessionInfo(rhsSortIndex, rhsText) = rhs, lhsSortIndex == rhsSortIndex, lhsText == rhsText {
+                return true
+            } else {
+                return false
+            }
+        case let .pendingSessionsHeader(lhsSortIndex, lhsText):
+            if case let .pendingSessionsHeader(rhsSortIndex, rhsText) = rhs, lhsSortIndex == rhsSortIndex, lhsText == rhsText {
+                return true
+            } else {
+                return false
+            }
+        case let .pendingSession(lhsIndex, lhsSortIndex, lhsStrings, lhsDateTimeFormat, lhsSession, lhsEnabled, lhsEditing, lhsRevealed):
+            if case let .pendingSession(rhsIndex, rhsSortIndex, rhsStrings, rhsDateTimeFormat, rhsSession, rhsEnabled, rhsEditing, rhsRevealed) = rhs, lhsIndex == rhsIndex, lhsSortIndex == rhsSortIndex, lhsStrings === rhsStrings, lhsDateTimeFormat == rhsDateTimeFormat, lhsSession == rhsSession, lhsEnabled == rhsEnabled, lhsEditing == rhsEditing, lhsRevealed == rhsRevealed {
+                return true
+            } else {
+                return false
+            }
+        case let .pendingSessionsInfo(lhsSortIndex, lhsText):
+            if case let .pendingSessionsInfo(rhsSortIndex, rhsText) = rhs, lhsSortIndex == rhsSortIndex, lhsText == rhsText {
+                return true
+            } else {
+                return false
+            }
+        case let .otherSessionsHeader(lhsSortIndex, lhsText):
+            if case let .otherSessionsHeader(rhsSortIndex, rhsText) = rhs, lhsSortIndex == rhsSortIndex, lhsText == rhsText {
+                return true
+            } else {
+                return false
+            }
+        case let .addDevice(lhsSortIndex, lhsText):
+            if case let .addDevice(rhsSortIndex, rhsText) = rhs, lhsSortIndex == rhsSortIndex, lhsText == rhsText {
+                return true
+            } else {
+                return false
+            }
+        case let .currentSession(lhsSortIndex, lhsStrings, lhsDateTimeFormat, lhsSession):
+            if case let .currentSession(rhsSortIndex, rhsStrings, rhsDateTimeFormat, rhsSession) = rhs, lhsSortIndex == rhsSortIndex, lhsStrings === rhsStrings, lhsDateTimeFormat == rhsDateTimeFormat, lhsSession == rhsSession {
+                return true
+            } else {
+                return false
+            }
+        case let .session(lhsIndex, lhsSortIndex, lhsStrings, lhsDateTimeFormat, lhsSession, lhsEnabled, lhsEditing, lhsRevealed):
+            if case let .session(rhsIndex, rhsSortIndex, rhsStrings, rhsDateTimeFormat, rhsSession, rhsEnabled, rhsEditing, rhsRevealed) = rhs, lhsIndex == rhsIndex, lhsSortIndex == rhsSortIndex, lhsStrings === rhsStrings, lhsDateTimeFormat == rhsDateTimeFormat, lhsSession == rhsSession, lhsEnabled == rhsEnabled, lhsEditing == rhsEditing, lhsRevealed == rhsRevealed {
+                return true
+            } else {
+                return false
+            }
+        case let .website(lhsIndex, lhsSortIndex, lhsStrings, lhsDateTimeFormat, lhsNameOrder, lhsWebsite, lhsPeer, lhsEnabled, lhsEditing, lhsRevealed):
+            if case let .website(rhsIndex, rhsSortIndex, rhsStrings, rhsDateTimeFormat, rhsNameOrder, rhsWebsite, rhsPeer, rhsEnabled, rhsEditing, rhsRevealed) = rhs, lhsIndex == rhsIndex, lhsSortIndex == rhsSortIndex, lhsStrings === rhsStrings, lhsDateTimeFormat == rhsDateTimeFormat, lhsNameOrder == rhsNameOrder, lhsWebsite == rhsWebsite, arePeersEqual(lhsPeer, rhsPeer), lhsEnabled == rhsEnabled, lhsEditing == rhsEditing, lhsRevealed == rhsRevealed {
+                return true
+            } else {
+                return false
+            }
+        case let .devicesInfo(lhsSortIndex, lhsText):
+            if case let .devicesInfo(rhsSortIndex, rhsText) = rhs, lhsSortIndex == rhsSortIndex, lhsText == rhsText {
+                return true
+            } else {
+                return false
+            }
+        case let .ttlHeader(lhsSortIndex, lhsText):
+            if case let .ttlHeader(rhsSortIndex, rhsText) = rhs, lhsSortIndex == rhsSortIndex, lhsText == rhsText {
+                return true
+            } else {
+                return false
+            }
+        case let .ttlTimeout(lhsSortIndex, lhsText, lhsValue):
+            if case let .ttlTimeout(rhsSortIndex, rhsText, rhsValue) = rhs, lhsSortIndex == rhsSortIndex, lhsText == rhsText, lhsValue == rhsValue {
+                return true
+            } else {
+                return false
+            }
+        }
+    }
+    
+    static func <(lhs: RecentSessionsEntry, rhs: RecentSessionsEntry) -> Bool {
+        return lhs.sortIndex < rhs.sortIndex
+    }
+    
+    func item(presentationData: ItemListPresentationData, arguments: Any) -> ListViewItem {
+        let arguments = arguments as! RecentSessionsControllerArguments
+        switch self {
+        case let .header(_, text):
+            return RecentSessionsHeaderItem(context: arguments.context, theme: presentationData.theme, text: text, animationName: "Devices", sectionId: self.section, buttonAction: {
+                arguments.addDevice()
+            }, linkAction: { action in
+                if case let .tap(link) = action {
+                    switch link {
+                    case "desktop":
+                        arguments.openDesktopLink()
+                    case "web":
+                        arguments.openWebLink()
+                    default:
+                        break
+                    }
+                }
+            })
+        case let .currentSessionHeader(_, text):
+            return ItemListSectionHeaderItem(presentationData: presentationData, text: text, sectionId: self.section)
+        case let .currentSession(_, _, dateTimeFormat, session):
+            return ItemListRecentSessionItem(presentationData: presentationData, systemStyle: .glass, dateTimeFormat: dateTimeFormat, session: session, enabled: true, editable: false, editing: false, revealed: false, sectionId: self.section, setSessionIdWithRevealedOptions: { _, _ in
+            }, removeSession: { _ in
+            }, action: {
+                arguments.openSession(session)
+            })
+        case let .terminateOtherSessions(_, text):
+            return ItemListPeerActionItem(presentationData: presentationData, systemStyle: .glass, icon: PresentationResourcesItemList.blockDestructiveIcon(presentationData.theme), title: text, sectionId: self.section, height: .generic, color: .destructive, editing: false, action: {
+                arguments.terminateOtherSessions()
+            })
+        case let .terminateAllWebSessions(_, text):
+            return ItemListPeerActionItem(presentationData: presentationData, systemStyle: .glass, icon: PresentationResourcesItemList.blockDestructiveIcon(presentationData.theme), title: text, sectionId: self.section, height: .generic, color: .destructive, editing: false, action: {
+                arguments.terminateAllWebSessions()
+            })
+        case let .currentAddDevice(_, text):
+            return ItemListPeerActionItem(presentationData: presentationData, systemStyle: .glass, icon: PresentationResourcesItemList.addDeviceIcon(presentationData.theme), title: text, sectionId: self.section, height: .generic, color: .accent, editing: false, action: {
+                arguments.addDevice()
+            })
+        case let .currentSessionInfo(_, text):
+            return ItemListTextItem(presentationData: presentationData, text: .markdown(text), sectionId: self.section, linkAction: { action in
+                switch action {
+                case .tap:
+                    arguments.openOtherAppsUrl()
+                }
+            })
+        case let .pendingSessionsHeader(_, text):
+            return ItemListSectionHeaderItem(presentationData: presentationData, text: text, sectionId: self.section)
+        case let .pendingSession(_, _, _, dateTimeFormat, session, enabled, editing, revealed):
+            return ItemListRecentSessionItem(presentationData: presentationData, systemStyle: .glass, dateTimeFormat: dateTimeFormat, session: session, enabled: enabled, editable: true, editing: editing, revealed: revealed, sectionId: self.section, setSessionIdWithRevealedOptions: { previousId, id in
+                arguments.setSessionIdWithRevealedOptions(previousId, id)
+            }, removeSession: { id in
+                arguments.removeSession(id)
+            }, action: {
+                arguments.openSession(session)
+            })
+        case let .pendingSessionsInfo(_, text):
+            return ItemListTextItem(presentationData: presentationData, text: .plain(text), sectionId: self.section)
+        case let .otherSessionsHeader(_, text):
+            return ItemListSectionHeaderItem(presentationData: presentationData, text: text, sectionId: self.section)
+        case let .addDevice(_, text):
+            return ItemListPeerActionItem(presentationData: presentationData, systemStyle: .glass, icon: PresentationResourcesItemList.addDeviceIcon(presentationData.theme), title: text, sectionId: self.section, height: .generic, color: .accent, editing: false, action: {
+                arguments.addDevice()
+            })
+        case let .session(_, _, _, dateTimeFormat, session, enabled, editing, revealed):
+            return ItemListRecentSessionItem(presentationData: presentationData, systemStyle: .glass, dateTimeFormat: dateTimeFormat, session: session, enabled: enabled, editable: true, editing: editing, revealed: revealed, sectionId: self.section, setSessionIdWithRevealedOptions: { previousId, id in
+                arguments.setSessionIdWithRevealedOptions(previousId, id)
+            }, removeSession: { id in
+                arguments.removeSession(id)
+            }, action: {
+                arguments.openSession(session)
+            })
+        case let .website(_, _, _, dateTimeFormat, nameDisplayOrder, website, peer, enabled, editing, revealed):
+            return ItemListWebsiteItem(context: arguments.context, presentationData: presentationData, systemStyle: .glass, dateTimeFormat: dateTimeFormat, nameDisplayOrder: nameDisplayOrder, website: website, peer: peer, enabled: enabled, editing: editing, revealed: revealed, sectionId: self.section, setSessionIdWithRevealedOptions: { previousId, id in
+                arguments.setSessionIdWithRevealedOptions(previousId, id)
+            }, removeSession: { id in
+                arguments.removeWebSession(id)
+            }, action: {
+                arguments.openWebSession(website, peer)
+            })
+        case let .devicesInfo(_, text):
+            return ItemListTextItem(presentationData: presentationData, text: .markdown(text), sectionId: self.section, linkAction: { action in
+                switch action {
+                case .tap:
+                    arguments.openOtherAppsUrl()
+                }
+            })
+        case let .ttlHeader(_, text):
+            return ItemListSectionHeaderItem(presentationData: presentationData, text: text, sectionId: self.section)
+        case let .ttlTimeout(_, text, value):
+            return ItemListDisclosureItem(presentationData: presentationData, systemStyle: .glass, title: text, label: value, sectionId: self.section, style: .blocks, action: {
+                arguments.setupAuthorizationTTL()
+            }, tag: PrivacyAndSecurityEntryTag.accountTimeout)
+        }
+    }
+}
+
+private struct RecentSessionsControllerState: Equatable {
+    let editing: Bool
+    let sessionIdWithRevealedOptions: Int64?
+    let removingSessionId: Int64?
+    let terminatingOtherSessions: Bool
+    
+    init() {
+        self.editing = false
+        self.sessionIdWithRevealedOptions = nil
+        self.removingSessionId = nil
+        self.terminatingOtherSessions = false
+    }
+    
+    init(editing: Bool, sessionIdWithRevealedOptions: Int64?, removingSessionId: Int64?, terminatingOtherSessions: Bool) {
+        self.editing = editing
+        self.sessionIdWithRevealedOptions = sessionIdWithRevealedOptions
+        self.removingSessionId = removingSessionId
+        self.terminatingOtherSessions = terminatingOtherSessions
+    }
+    
+    static func ==(lhs: RecentSessionsControllerState, rhs: RecentSessionsControllerState) -> Bool {
+        if lhs.editing != rhs.editing {
+            return false
+        }
+        if lhs.sessionIdWithRevealedOptions != rhs.sessionIdWithRevealedOptions {
+            return false
+        }
+        if lhs.removingSessionId != rhs.removingSessionId {
+            return false
+        }
+        if lhs.terminatingOtherSessions != rhs.terminatingOtherSessions {
+            return false
+        }
+        
+        return true
+    }
+    
+    func withUpdatedEditing(_ editing: Bool) -> RecentSessionsControllerState {
+        return RecentSessionsControllerState(editing: editing, sessionIdWithRevealedOptions: self.sessionIdWithRevealedOptions, removingSessionId: self.removingSessionId, terminatingOtherSessions: self.terminatingOtherSessions)
+    }
+    
+    func withUpdatedSessionIdWithRevealedOptions(_ sessionIdWithRevealedOptions: Int64?) -> RecentSessionsControllerState {
+        return RecentSessionsControllerState(editing: self.editing, sessionIdWithRevealedOptions: sessionIdWithRevealedOptions, removingSessionId: self.removingSessionId, terminatingOtherSessions: self.terminatingOtherSessions)
+    }
+    
+    func withUpdatedRemovingSessionId(_ removingSessionId: Int64?) -> RecentSessionsControllerState {
+        return RecentSessionsControllerState(editing: self.editing, sessionIdWithRevealedOptions: self.sessionIdWithRevealedOptions, removingSessionId: removingSessionId, terminatingOtherSessions: self.terminatingOtherSessions)
+    }
+    
+    func withUpdatedTerminatingOtherSessions(_ terminatingOtherSessions: Bool) -> RecentSessionsControllerState {
+        return RecentSessionsControllerState(editing: self.editing, sessionIdWithRevealedOptions: self.sessionIdWithRevealedOptions, removingSessionId: self.removingSessionId, terminatingOtherSessions: terminatingOtherSessions)
+    }
+}
+
+private func recentSessionsControllerEntries(presentationData: PresentationData, state: RecentSessionsControllerState, sessionsState: ActiveSessionsContextState, enableQRLogin: Bool) -> [RecentSessionsEntry] {
+    var entries: [RecentSessionsEntry] = []
+    
+    entries.append(.header(SortIndex(section: 0, item: 0), presentationData.strings.AuthSessions_HeaderInfo))
+    
+    if !sessionsState.sessions.isEmpty {
+        var existingSessionIds = Set<Int64>()
+        entries.append(.currentSessionHeader(SortIndex(section: 1, item: 0), presentationData.strings.AuthSessions_CurrentSession))
+        if let index = sessionsState.sessions.firstIndex(where: { $0.hash == 0 }) {
+            existingSessionIds.insert(sessionsState.sessions[index].hash)
+            entries.append(.currentSession(SortIndex(section: 1, item: 1), presentationData.strings, presentationData.dateTimeFormat, sessionsState.sessions[index]))
+        }
+        
+        var hasAddDevice = false
+        if sessionsState.sessions.count > 1 || enableQRLogin {
+            if sessionsState.sessions.count > 1 {
+                entries.append(.terminateOtherSessions(SortIndex(section: 1, item: 2), presentationData.strings.AuthSessions_TerminateOtherSessions))
+                entries.append(.currentSessionInfo(SortIndex(section: 1, item: 3), presentationData.strings.AuthSessions_TerminateOtherSessionsHelp))
+            } else if enableQRLogin {
+                hasAddDevice = true
+//                entries.append(.currentAddDevice(SortIndex(section: 1, item: 4), presentationData.strings.AuthSessions_AddDevice))
+                entries.append(.currentSessionInfo(SortIndex(section: 1, item: 5), presentationData.strings.AuthSessions_OtherDevices))
+            }
+            
+            let filteredPendingSessions: [RecentAccountSession] = sessionsState.sessions.filter({ $0.flags.contains(.passwordPending) })
+            if !filteredPendingSessions.isEmpty {
+                entries.append(.pendingSessionsHeader(SortIndex(section: 1, item: 6), presentationData.strings.AuthSessions_IncompleteAttempts))
+                for i in 0 ..< filteredPendingSessions.count {
+                    if !existingSessionIds.contains(filteredPendingSessions[i].hash) {
+                        existingSessionIds.insert(filteredPendingSessions[i].hash)
+                        entries.append(.pendingSession(index: Int32(i), sortIndex: SortIndex(section: 2, item: i), strings: presentationData.strings, dateTimeFormat: presentationData.dateTimeFormat, session: filteredPendingSessions[i], enabled: state.removingSessionId != filteredPendingSessions[i].hash && !state.terminatingOtherSessions, editing: state.editing, revealed: state.sessionIdWithRevealedOptions == filteredPendingSessions[i].hash))
+                    }
+                }
+                entries.append(.pendingSessionsInfo(SortIndex(section: 3, item: 0), presentationData.strings.AuthSessions_IncompleteAttemptsInfo))
+            }
+            
+            if sessionsState.sessions.count > 1 {
+                entries.append(.otherSessionsHeader(SortIndex(section: 4, item: 0), presentationData.strings.AuthSessions_OtherSessions))
+            }
+            
+//            if enableQRLogin && !hasAddDevice {
+//                entries.append(.addDevice(SortIndex(section: 4, item: 1), presentationData.strings.AuthSessions_AddDevice))
+//            }
+            
+            let filteredSessions: [RecentAccountSession] = sessionsState.sessions.sorted(by: { lhs, rhs in
+                return lhs.activityDate > rhs.activityDate
+            })
+            
+            for i in 0 ..< filteredSessions.count {
+                if !existingSessionIds.contains(filteredSessions[i].hash) {
+                    existingSessionIds.insert(filteredSessions[i].hash)
+                    entries.append(.session(index: Int32(i), sortIndex: SortIndex(section: 5, item: i), strings: presentationData.strings, dateTimeFormat: presentationData.dateTimeFormat, session: filteredSessions[i], enabled: state.removingSessionId != filteredSessions[i].hash && !state.terminatingOtherSessions, editing: state.editing, revealed: state.sessionIdWithRevealedOptions == filteredSessions[i].hash))
+                }
+            }
+            
+            if enableQRLogin && !hasAddDevice {
+                entries.append(.devicesInfo(SortIndex(section: 6, item: 0), presentationData.strings.AuthSessions_OtherDevices))
+            }
+        }
+        
+        entries.append(.ttlHeader(SortIndex(section: 7, item: 0), presentationData.strings.AuthSessions_TerminateIfAwayTitle.uppercased()))
+        entries.append(.ttlTimeout(SortIndex(section: 7, item: 1), presentationData.strings.AuthSessions_TerminateIfAwayFor, timeIntervalString(strings: presentationData.strings, value: sessionsState.ttlDays * 24 * 60 * 60)))
+    }
+    
+    return entries
+}
+
+private func recentSessionsControllerEntries(presentationData: PresentationData, state: RecentSessionsControllerState, websites: [WebAuthorization]?, peers: [PeerId : Peer]?) -> [RecentSessionsEntry] {
+    var entries: [RecentSessionsEntry] = []
+    
+    if let websites = websites, let peers = peers {
+        var existingSessionIds = Set<Int64>()
+        if websites.count > 0 {
+            entries.append(.terminateAllWebSessions(SortIndex(section: 0, item: 0), presentationData.strings.AuthSessions_LogOutApplications))
+            entries.append(.currentSessionInfo(SortIndex(section: 0, item: 1), presentationData.strings.AuthSessions_LogOutApplicationsHelp))
+            
+            entries.append(.otherSessionsHeader(SortIndex(section: 0, item: 2), presentationData.strings.AuthSessions_LoggedInWithTelegram))
+            
+            let filteredWebsites: [WebAuthorization] = websites.sorted(by: { lhs, rhs in
+                return lhs.dateActive > rhs.dateActive
+            })
+            
+            for i in 0 ..< filteredWebsites.count {
+                let website = websites[i]
+                if !existingSessionIds.contains(website.hash) {
+                    existingSessionIds.insert(website.hash)
+                    entries.append(.website(index: Int32(i), sortIndex: SortIndex(section: 1, item: i), strings: presentationData.strings, dateTimeFormat: presentationData.dateTimeFormat, nameDisplayOrder: presentationData.nameDisplayOrder, website: website, peer: peers[website.botId], enabled: state.removingSessionId != website.hash && !state.terminatingOtherSessions, editing: state.editing, revealed: state.sessionIdWithRevealedOptions == website.hash))
+                }
+            }
+        }
+    }
+    
+    return entries
+}
+
+private final class RecentSessionsControllerImpl: ItemListController, RecentSessionsController {
+}
+
+public func recentSessionsController(context: AccountContext, activeSessionsContext: ActiveSessionsContext, webSessionsContext: WebSessionsContext, websitesOnly: Bool) -> ViewController & RecentSessionsController {
+    let statePromise = ValuePromise(RecentSessionsControllerState(), ignoreRepeated: true)
+    let stateValue = Atomic(value: RecentSessionsControllerState())
+    let updateState: ((RecentSessionsControllerState) -> RecentSessionsControllerState) -> Void = { f in
+        statePromise.set(stateValue.modify { f($0) })
+    }
+    
+    activeSessionsContext.loadMore()
+    webSessionsContext.loadMore()
+    
+    var presentControllerImpl: ((ViewController, ViewControllerPresentationArguments?) -> Void)?
+    var pushControllerImpl: ((ViewController) -> Void)?
+    var dismissImpl: (() -> Void)?
+    
+    let actionsDisposable = DisposableSet()
+    
+    let removeSessionDisposable = MetaDisposable()
+    actionsDisposable.add(removeSessionDisposable)
+    
+    let terminateOtherSessionsDisposable = MetaDisposable()
+    actionsDisposable.add(terminateOtherSessionsDisposable)
+    
+    let didAppearValue = ValuePromise<Bool>(false)
+    
+    if websitesOnly {
+        let autoDismissDisposable = (webSessionsContext.state
+        |> filter { !$0.isLoadingMore && $0.sessions.isEmpty }
+        |> take(1)
+        |> mapToSignal { _ in
+            return didAppearValue.get()
+            |> filter { $0 }
+            |> take(1)
+        }
+        |> deliverOnMainQueue).start(next: { _ in
+            dismissImpl?()
+        })
+        actionsDisposable.add(autoDismissDisposable)
+    }
+    
+    let mode = ValuePromise<RecentSessionsMode>(websitesOnly ? .websites : .sessions)
+    
+    let removeSessionImpl: (Int64, @escaping () -> Void) -> Void = { sessionId, completion in
+        let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+        let controller = ActionSheetController(presentationData: presentationData)
+        let dismissAction: () -> Void = { [weak controller] in
+            controller?.dismissAnimated()
+        }
+        controller.setItemGroups([
+            ActionSheetItemGroup(items: [
+                ActionSheetTextItem(title: presentationData.strings.AuthSessions_TerminateSessionText),
+                ActionSheetButtonItem(title: presentationData.strings.AuthSessions_TerminateSession, color: .destructive, action: {
+                    dismissAction()
+                    completion()
+                    
+                    updateState {
+                        return $0.withUpdatedRemovingSessionId(sessionId)
+                    }
+                    
+                    removeSessionDisposable.set((activeSessionsContext.remove(hash: sessionId)
+                    |> deliverOnMainQueue).start(error: { _ in
+                        updateState {
+                            return $0.withUpdatedRemovingSessionId(nil)
+                        }
+                    }, completed: {
+                        updateState {
+                            return $0.withUpdatedRemovingSessionId(nil)
+                        }
+                        context.sharedContext.updateNotificationTokensRegistration()
+                    }))
+                })
+            ]),
+            ActionSheetItemGroup(items: [ActionSheetButtonItem(title: presentationData.strings.Common_Cancel, action: { dismissAction() })])
+        ])
+        presentControllerImpl?(controller, ViewControllerPresentationArguments(presentationAnimation: .modalSheet))
+    }
+    
+    let removeWebSessionImpl: (Int64) -> Void = { sessionId in
+        updateState {
+            return $0.withUpdatedRemovingSessionId(sessionId)
+        }
+        
+        removeSessionDisposable.set(((webSessionsContext.remove(hash: sessionId)
+        |> mapToSignal { _ -> Signal<Void, NoError> in
+        })
+        |> deliverOnMainQueue).start(error: { _ in
+        }, completed: {
+            updateState {
+                return $0.withUpdatedRemovingSessionId(nil)
+            }
+        }))
+    }
+    
+    let updateAuthorizationTTLDisposable = MetaDisposable()
+    actionsDisposable.add(updateAuthorizationTTLDisposable)
+    
+    let updateSessionDisposable = MetaDisposable()
+    actionsDisposable.add(updateSessionDisposable)
+    
+    let arguments = RecentSessionsControllerArguments(context: context, setSessionIdWithRevealedOptions: { sessionId, fromSessionId in
+        updateState { state in
+            if (sessionId == nil && fromSessionId == state.sessionIdWithRevealedOptions) || (sessionId != nil && fromSessionId == nil) {
+                return state.withUpdatedSessionIdWithRevealedOptions(sessionId)
+            } else {
+                return state
+            }
+        }
+    }, removeSession: { sessionId in
+        removeSessionImpl(sessionId, {})
+    }, terminateOtherSessions: {
+        let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+        let controller = ActionSheetController(presentationData: presentationData)
+        let dismissAction: () -> Void = { [weak controller] in
+            controller?.dismissAnimated()
+        }
+        controller.setItemGroups([
+            ActionSheetItemGroup(items: [
+                ActionSheetTextItem(title: presentationData.strings.AuthSessions_TerminateOtherSessionsText),
+                ActionSheetButtonItem(title: presentationData.strings.AuthSessions_TerminateOtherSessions, color: .destructive, action: {
+                    dismissAction()
+                    
+                    updateState {
+                        return $0.withUpdatedTerminatingOtherSessions(true)
+                    }
+                    
+                    terminateOtherSessionsDisposable.set((activeSessionsContext.removeOther()
+                    |> deliverOnMainQueue).start(error: { _ in
+                        updateState {
+                            return $0.withUpdatedTerminatingOtherSessions(false)
+                        }
+                    }, completed: {
+                        updateState {
+                            return $0.withUpdatedTerminatingOtherSessions(false)
+                        }
+                        context.sharedContext.updateNotificationTokensRegistration()
+                    }))
+                })
+            ]),
+            ActionSheetItemGroup(items: [ActionSheetButtonItem(title: presentationData.strings.Common_Cancel, action: { dismissAction() })])
+            ])
+        presentControllerImpl?(controller, ViewControllerPresentationArguments(presentationAnimation: .modalSheet))
+    }, openSession: { session in
+        let controller = RecentSessionScreen(context: context, subject: .session(session), updateAcceptSecretChats: { value in
+            updateSessionDisposable.set(activeSessionsContext.updateSessionAcceptsSecretChats(session, accepts: value).start())
+        }, updateAcceptIncomingCalls: { value in
+            updateSessionDisposable.set(activeSessionsContext.updateSessionAcceptsIncomingCalls(session, accepts: value).start())
+        }, remove: { completion in
+            removeSessionImpl(session.hash, {
+                completion()
+            })
+        })
+        presentControllerImpl?(controller, nil)
+    }, openWebSession: { session, peer in
+        let controller = RecentSessionScreen(context: context, subject: .website(session, peer.flatMap(EnginePeer.init)), updateAcceptSecretChats: { _ in }, updateAcceptIncomingCalls: { _ in }, remove: { completion in
+            removeWebSessionImpl(session.hash)
+            completion()
+        })
+        presentControllerImpl?(controller, nil)
+    }, removeWebSession: { sessionId in
+        removeWebSessionImpl(sessionId)
+    }, terminateAllWebSessions: {
+        let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+        let controller = ActionSheetController(presentationData: presentationData)
+        let dismissAction: () -> Void = { [weak controller] in
+            controller?.dismissAnimated()
+        }
+        controller.setItemGroups([
+            ActionSheetItemGroup(items: [
+                ActionSheetButtonItem(title: presentationData.strings.AuthSessions_LogOutApplications, color: .destructive, action: {
+                    dismissAction()
+                    
+                    updateState {
+                        return $0.withUpdatedTerminatingOtherSessions(true)
+                    }
+                    
+                    terminateOtherSessionsDisposable.set((webSessionsContext.removeAll()
+                    |> deliverOnMainQueue).start(error: { _ in
+                    }, completed: {
+                        updateState {
+                            return $0.withUpdatedTerminatingOtherSessions(false)
+                        }
+                        mode.set(.sessions)
+                    }))
+                })
+            ]),
+            ActionSheetItemGroup(items: [ActionSheetButtonItem(title: presentationData.strings.Common_Cancel, action: { dismissAction() })])
+            ])
+        presentControllerImpl?(controller, ViewControllerPresentationArguments(presentationAnimation: .modalSheet))
+    }, addDevice: {
+        let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+        DeviceAccess.authorizeAccess(to: .camera(.qrCode), presentationData: presentationData, present: { c, a in
+            c.presentationArguments = a
+            context.sharedContext.mainWindow?.present(c, on: .root)
+        }, openSettings: {
+            context.sharedContext.applicationBindings.openSettings()
+        }, { granted in
+            guard granted else {
+                return
+            }
+            pushControllerImpl?(QrCodeScanScreen(context: context, subject: .authTransfer(activeSessionsContext: activeSessionsContext)))
+        })
+    }, openOtherAppsUrl: {
+        context.sharedContext.openExternalUrl(context: context, urlContext: .generic, url: "https://telegram.org/apps", forceExternal: true, presentationData: context.sharedContext.currentPresentationData.with { $0 }, navigationController: nil, dismissInput: {})
+    }, setupAuthorizationTTL: {
+        let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+        let controller = ActionSheetController(presentationData: presentationData)
+        let dismissAction: () -> Void = { [weak controller] in
+            controller?.dismissAnimated()
+        }
+        let ttlAction: (Int32) -> Void = { ttl in
+            updateAuthorizationTTLDisposable.set(activeSessionsContext.updateAuthorizationTTL(days: ttl).start())
+        }
+        let timeoutValues: [Int32] = [
+            7,
+            30,
+            90,
+            180
+        ]
+        let timeoutItems: [ActionSheetItem] = timeoutValues.map { value in
+            return ActionSheetButtonItem(title: timeIntervalString(strings: presentationData.strings, value: value * 24 * 60 * 60), action: {
+                dismissAction()
+                ttlAction(value)
+            })
+        }
+        controller.setItemGroups([
+            ActionSheetItemGroup(items: timeoutItems),
+            ActionSheetItemGroup(items: [ActionSheetButtonItem(title: presentationData.strings.Common_Cancel, action: { dismissAction() })])
+        ])
+        presentControllerImpl?(controller, nil)
+    }, openDesktopLink: {
+        context.sharedContext.openExternalUrl(context: context, urlContext: .generic, url: "https://getdesktop.telegram.org", forceExternal: true, presentationData: context.sharedContext.currentPresentationData.with { $0 }, navigationController: nil, dismissInput: {})
+    }, openWebLink: {
+        context.sharedContext.openExternalUrl(context: context, urlContext: .generic, url: "https://web.telegram.org", forceExternal: true, presentationData: context.sharedContext.currentPresentationData.with { $0 }, navigationController: nil, dismissInput: {})
+    })
+    
+    let previousMode = Atomic<RecentSessionsMode>(value: .sessions)
+    
+    let enableQRLogin = context.account.postbox.preferencesView(keys: [PreferencesKeys.appConfiguration])
+    |> map { view -> Bool in
+        guard let appConfiguration = view.values[PreferencesKeys.appConfiguration]?.get(AppConfiguration.self) else {
+            return false
+        }
+        guard let data = appConfiguration.data, let enableQR = data["qr_login_camera"] as? Bool, enableQR else {
+            return false
+        }
+        return true
+    }
+    |> distinctUntilChanged
+    
+    let signal = combineLatest(context.sharedContext.presentationData, mode.get(), statePromise.get(), activeSessionsContext.state, webSessionsContext.state, enableQRLogin)
+    |> deliverOnMainQueue
+    |> map { presentationData, mode, state, sessionsState, websitesAndPeers, enableQRLogin -> (ItemListControllerState, (ItemListNodeState, Any)) in
+        var rightNavigationButton: ItemListNavigationButton?
+        let websites = websitesAndPeers.sessions
+        let peers = websitesAndPeers.peers
+        
+        if sessionsState.sessions.count > 1 {
+            if state.terminatingOtherSessions {
+                rightNavigationButton = ItemListNavigationButton(content: .none, style: .activity, enabled: true, action: {})
+            } else if state.editing {
+                rightNavigationButton = ItemListNavigationButton(content: .text(presentationData.strings.Common_Done), style: .bold, enabled: true, action: {
+                    updateState { state in
+                        return state.withUpdatedEditing(false)
+                    }
+                })
+            } else {
+                rightNavigationButton = ItemListNavigationButton(content: .text(presentationData.strings.Common_Edit), style: .regular, enabled: true, action: {
+                    updateState { state in
+                        return state.withUpdatedEditing(true)
+                    }
+                })
+            }
+        }
+        
+        let emptyStateItem: ItemListControllerEmptyStateItem? = nil
+//        if sessionsState.sessions.count == 1 && mode == .sessions {
+//            emptyStateItem = RecentSessionsEmptyStateItem(theme: presentationData.theme, strings: presentationData.strings)
+//        } else {
+//            emptyStateItem = nil
+//        }
+        
+        let title: ItemListControllerTitle
+        let entries: [RecentSessionsEntry]
+        if websitesOnly {
+            title = .text(presentationData.strings.AuthSessions_LoggedIn)
+        } else {
+            title = .text(presentationData.strings.AuthSessions_DevicesTitle)
+        }
+        
+        var animateChanges = true
+        switch (mode, websites, peers) {
+            case (.websites, let websites, let peers):
+                entries = recentSessionsControllerEntries(presentationData: presentationData, state: state, websites: websites, peers: peers)
+            default:
+                entries = recentSessionsControllerEntries(presentationData: presentationData, state: state, sessionsState: sessionsState, enableQRLogin: enableQRLogin)
+        }
+        
+        let previousMode = previousMode.swap(mode)
+        var crossfadeState = false
+        
+        if previousMode != mode {
+            crossfadeState = true
+            animateChanges = false
+        }
+        
+        let controllerState = ItemListControllerState(presentationData: ItemListPresentationData(presentationData), title: title, leftNavigationButton: nil, rightNavigationButton: rightNavigationButton, backNavigationButton: ItemListBackButton(title: presentationData.strings.Common_Back), animateChanges: true)
+        let listState = ItemListNodeState(presentationData: ItemListPresentationData(presentationData), entries: entries, style: .blocks, emptyStateItem: emptyStateItem, crossfadeState: crossfadeState, animateChanges: animateChanges, scrollEnabled: emptyStateItem == nil)
+        
+        return (controllerState, (listState, arguments))
+    } |> afterDisposed {
+        actionsDisposable.dispose()
+    }
+    
+    let controller = RecentSessionsControllerImpl(context: context, state: signal)
+    controller.titleControlValueChanged = { [weak mode] index in
+        mode?.set(index == 0 ? .sessions : .websites)
+    }
+    controller.didAppear = { _ in
+        didAppearValue.set(true)
+    }
+    presentControllerImpl = { [weak controller] c, p in
+        if let controller = controller {
+            controller.present(c, in: .window(.root), with: p)
+        }
+    }
+    pushControllerImpl = { [weak controller] c in
+        controller?.push(c)
+    }
+    dismissImpl = { [weak controller] in
+        controller?.dismiss()
+    }
+    
+    return controller
+}

submodules/SettingsUI/Sources/Privacy and Security/Recent Sessions/RecentSessionsEmptyStateItem.swift

@@ -0,0 +1,115 @@
+import Foundation
+import UIKit
+import AsyncDisplayKit
+import Display
+import TelegramPresentationData
+import ItemListUI
+import PresentationDataUtils
+import AppBundle
+
+final class RecentSessionsEmptyStateItem: ItemListControllerEmptyStateItem {
+    let theme: PresentationTheme
+    let strings: PresentationStrings
+    
+    init(theme: PresentationTheme, strings: PresentationStrings) {
+        self.theme = theme
+        self.strings = strings
+    }
+    
+    func isEqual(to: ItemListControllerEmptyStateItem) -> Bool {
+        if let item = to as? RecentSessionsEmptyStateItem {
+            return self.theme === item.theme && self.strings === item.strings
+        } else {
+            return false
+        }
+    }
+    
+    func node(current: ItemListControllerEmptyStateItemNode?) -> ItemListControllerEmptyStateItemNode {
+        if let current = current as? RecentSessionsEmptyStateItemNode {
+            current.item = self
+            return current
+        } else {
+            return RecentSessionsEmptyStateItemNode(item: self)
+        }
+    }
+}
+
+final class RecentSessionsEmptyStateItemNode: ItemListControllerEmptyStateItemNode {
+    private let imageNode: ASImageNode
+    private let titleNode: ASTextNode
+    private let textNode: ASTextNode
+    private var validLayout: (ContainerViewLayout, CGFloat)?
+    
+    var item: RecentSessionsEmptyStateItem {
+        didSet {
+            self.updateThemeAndStrings(theme: self.item.theme, strings: self.item.strings)
+            if let (layout, navigationHeight) = self.validLayout {
+                self.updateLayout(layout: layout, navigationBarHeight: navigationHeight, transition: .immediate)
+            }
+        }
+    }
+    
+    init(item: RecentSessionsEmptyStateItem) {
+        self.item = item
+        
+        self.imageNode = ASImageNode()
+        
+        self.titleNode = ASTextNode()
+        self.titleNode.isUserInteractionEnabled = false
+        
+        self.textNode = ASTextNode()
+        self.textNode.isUserInteractionEnabled = false
+        
+        super.init()
+        
+        self.addSubnode(self.imageNode)
+        self.addSubnode(self.titleNode)
+        self.addSubnode(self.textNode)
+        
+        self.updateThemeAndStrings(theme: self.item.theme, strings: self.item.strings)
+    }
+    
+    private func updateThemeAndStrings(theme: PresentationTheme, strings: PresentationStrings) {
+        self.imageNode.image = generateTintedImage(image: UIImage(bundleImageName: "Settings/RecentSessionsPlaceholder"), color: theme.list.freeTextColor)
+        self.titleNode.attributedText = NSAttributedString(string: strings.AuthSessions_EmptyTitle, font: Font.bold(17.0), textColor: theme.list.freeTextColor, paragraphAlignment: .center)
+        self.textNode.attributedText = NSAttributedString(string: strings.AuthSessions_EmptyText, font: Font.regular(14.0), textColor: theme.list.freeTextColor, paragraphAlignment: .center)
+    }
+    
+    override func updateLayout(layout: ContainerViewLayout, navigationBarHeight: CGFloat, transition: ContainedViewLayoutTransition) {
+        self.validLayout = (layout, navigationBarHeight)
+        var insets = layout.insets(options: [])
+        insets.top += navigationBarHeight + 270.0
+        
+        let imageSpacing: CGFloat = 8.0
+        let textSpacing: CGFloat = 8.0
+        
+        let imageSize = self.imageNode.image?.size ?? CGSize()
+        let imageHeight = layout.size.width < layout.size.height ? imageSize.height + imageSpacing : 0.0
+        
+        var textVisible = true
+        if layout.size.width == 320 {
+            textVisible = false
+        }
+                
+        let titleSize = self.titleNode.measure(CGSize(width: layout.size.width - layout.safeInsets.left - layout.safeInsets.right - layout.intrinsicInsets.left - layout.intrinsicInsets.right - 50.0, height: max(1.0, layout.size.height - insets.top - insets.bottom)))
+        let textSize = self.textNode.measure(CGSize(width: layout.size.width - layout.safeInsets.left - layout.safeInsets.right - layout.intrinsicInsets.left - layout.intrinsicInsets.right - 50.0, height: max(1.0, layout.size.height - insets.top - insets.bottom)))
+        
+        var totalHeight = imageHeight + titleSize.height
+        if textVisible {
+            totalHeight += textSpacing + textSize.height
+        }
+        let topOffset = insets.top + floor((layout.size.height - insets.top - insets.bottom - totalHeight) / 2.0)
+        
+        var visible = true
+        if case .compact = layout.metrics.widthClass, layout.size.width > layout.size.height {
+            visible = false
+        }
+
+        transition.updateAlpha(node: self.imageNode, alpha: visible ? 1.0 : 0.0)
+        transition.updateAlpha(node: self.titleNode, alpha: visible ? 1.0 : 0.0)
+        transition.updateAlpha(node: self.textNode, alpha: visible && textVisible ? 1.0 : 0.0)
+        transition.updateFrame(node: self.imageNode, frame: CGRect(origin: CGPoint(x: floor((layout.size.width - imageSize.width) / 2.0), y: topOffset), size: imageSize))
+        transition.updateFrame(node: self.titleNode, frame: CGRect(origin: CGPoint(x: floor((layout.size.width - titleSize.width) / 2.0), y: topOffset + imageHeight), size: titleSize))
+        transition.updateFrame(node: self.textNode, frame: CGRect(origin: CGPoint(x: floor((layout.size.width - textSize.width) / 2.0), y: self.titleNode.frame.maxY + textSpacing), size: textSize))
+    }
+}

submodules/SettingsUI/Sources/Privacy and Security/Recent Sessions/RecentSessionsHeaderItem.swift

@@ -0,0 +1,243 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import TelegramPresentationData
+import ItemListUI
+import PresentationDataUtils
+import AnimatedStickerNode
+import TelegramAnimatedStickerNode
+import AccountContext
+import Markdown
+import TextFormat
+import SolidRoundedButtonNode
+import ComponentFlow
+import ButtonComponent
+import BundleIconComponent
+
+class RecentSessionsHeaderItem: ListViewItem, ItemListItem {
+    let context: AccountContext
+    let theme: PresentationTheme
+    let text: String
+    let animationName: String
+    let sectionId: ItemListSectionId
+    let buttonAction: () -> Void
+    let linkAction: ((ItemListTextItemLinkAction) -> Void)?
+    
+    init(context: AccountContext, theme: PresentationTheme, text: String, animationName: String, sectionId: ItemListSectionId, buttonAction: @escaping () -> Void, linkAction: ((ItemListTextItemLinkAction) -> Void)? = nil) {
+        self.context = context
+        self.theme = theme
+        self.text = text
+        self.animationName = animationName
+        self.sectionId = sectionId
+        self.buttonAction = buttonAction
+        self.linkAction = linkAction
+    }
+    
+    func nodeConfiguredForParams(async: @escaping (@escaping () -> Void) -> Void, params: ListViewItemLayoutParams, synchronousLoads: Bool, previousItem: ListViewItem?, nextItem: ListViewItem?, completion: @escaping (ListViewItemNode, @escaping () -> (Signal<Void, NoError>?, (ListViewItemApply) -> Void)) -> Void) {
+        async {
+            let node = RecentSessionsHeaderItemNode()
+            let (layout, apply) = node.asyncLayout()(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem))
+            
+            node.contentSize = layout.contentSize
+            node.insets = layout.insets
+            
+            Queue.mainQueue().async {
+                completion(node, {
+                    return (nil, { _ in apply() })
+                })
+            }
+        }
+    }
+    
+    func updateNode(async: @escaping (@escaping () -> Void) -> Void, node: @escaping () -> ListViewItemNode, params: ListViewItemLayoutParams, previousItem: ListViewItem?, nextItem: ListViewItem?, animation: ListViewItemUpdateAnimation, completion: @escaping (ListViewItemNodeLayout, @escaping (ListViewItemApply) -> Void) -> Void) {
+        Queue.mainQueue().async {
+            guard let nodeValue = node() as? RecentSessionsHeaderItemNode else {
+                assertionFailure()
+                return
+            }
+            
+            let makeLayout = nodeValue.asyncLayout()
+            
+            async {
+                let (layout, apply) = makeLayout(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem))
+                Queue.mainQueue().async {
+                    completion(layout, { _ in
+                        apply()
+                    })
+                }
+            }
+        }
+    }
+}
+
+private let titleFont = Font.regular(13.0)
+
+class RecentSessionsHeaderItemNode: ListViewItemNode {
+    private let titleNode: TextNode
+    private var animationNode: AnimatedStickerNode
+    private let buttonNode: SolidRoundedButtonNode
+    private let button = ComponentView<Empty>()
+    
+    private var item: RecentSessionsHeaderItem?
+    
+    init() {
+        self.titleNode = TextNode()
+        self.titleNode.isUserInteractionEnabled = true
+        self.titleNode.contentMode = .left
+        self.titleNode.contentsScale = UIScreen.main.scale
+        
+        self.animationNode = DefaultAnimatedStickerNodeImpl()
+        
+        self.buttonNode = SolidRoundedButtonNode(theme: SolidRoundedButtonTheme(backgroundColor: .black, foregroundColor: .white), fontSize: 16.0, height: 50.0, cornerRadius: 11.0)
+        
+        super.init(layerBacked: false, dynamicBounce: false)
+        
+        self.addSubnode(self.titleNode)
+        self.addSubnode(self.animationNode)
+        //self.addSubnode(self.buttonNode)
+    }
+    
+    override public func didLoad() {
+        super.didLoad()
+        
+        let recognizer = TapLongTapOrDoubleTapGestureRecognizer(target: self, action: #selector(self.tapLongTapOrDoubleTapGesture(_:)))
+        recognizer.tapActionAtPoint = { _ in
+            return .waitForSingleTap
+        }
+        self.titleNode.view.addGestureRecognizer(recognizer)
+        
+        self.buttonNode.pressed = { [weak self] in
+            if let strongSelf = self, let item = strongSelf.item {
+                item.buttonAction()
+            }
+        }
+    }
+    
+    func asyncLayout() -> (_ item: RecentSessionsHeaderItem, _ params: ListViewItemLayoutParams, _ neighbors: ItemListNeighbors) -> (ListViewItemNodeLayout, () -> Void) {
+        let makeTitleLayout = TextNode.asyncLayout(self.titleNode)
+        let currentItem = self.item
+        
+        return { item, params, neighbors in
+            var updatedTheme: PresentationTheme?
+            
+            let leftInset: CGFloat = 32.0 + params.leftInset
+            let topInset: CGFloat = 124.0
+            
+            if currentItem?.theme !== item.theme {
+                updatedTheme = item.theme
+            }
+            
+            let attributedText = parseMarkdownIntoAttributedString(item.text, attributes: MarkdownAttributes(body: MarkdownAttributeSet(font: titleFont, textColor: item.theme.list.freeTextColor), bold: MarkdownAttributeSet(font: titleFont, textColor: item.theme.list.freeTextColor), link: MarkdownAttributeSet(font: titleFont, textColor: item.theme.list.itemAccentColor), linkAttribute: { contents in
+                return (TelegramTextAttributes.URL, contents)
+            }))
+                
+            let (titleLayout, titleApply) = makeTitleLayout(TextNodeLayoutArguments(attributedString: attributedText, backgroundColor: nil, maximumNumberOfLines: 0, truncationType: .end, constrainedSize: CGSize(width: params.width - params.rightInset - leftInset * 2.0, height: CGFloat.greatestFiniteMagnitude), alignment: .center, cutout: nil, insets: UIEdgeInsets()))
+            
+            let contentSize = CGSize(width: params.width, height: topInset + titleLayout.size.height + 69.0)
+            let insets = itemListNeighborsGroupedInsets(neighbors, params)
+            
+            let layout = ListViewItemNodeLayout(contentSize: contentSize, insets: insets)
+            
+            return (layout, { [weak self] in
+                if let strongSelf = self {
+                    if strongSelf.item == nil {
+                        strongSelf.animationNode.autoplay = true
+                        strongSelf.animationNode.setup(source: AnimatedStickerNodeLocalFileSource(name: item.animationName), width: 256, height: 256, playbackMode: .still(.start), mode: .direct(cachePathPrefix: nil))
+                        strongSelf.animationNode.visibility = true
+                        Queue.mainQueue().after(0.3) {
+                            strongSelf.animationNode.play(firstFrame: false, fromIndex: nil)
+                        }
+                    }
+                    strongSelf.item = item
+                    
+                    strongSelf.buttonNode.title = item.context.sharedContext.currentPresentationData.with { $0 }.strings.AuthSessions_LinkDesktopDevice
+                    if let _ = updatedTheme {
+                        strongSelf.buttonNode.icon = UIImage(bundleImageName: "Settings/QrButtonIcon")
+                        strongSelf.buttonNode.updateTheme(SolidRoundedButtonTheme(theme: item.theme))
+                    }
+                    
+                    let buttonSideInset: CGFloat = 36.0
+                    let buttonWidth = min(375, contentSize.width - buttonSideInset * 2.0)
+                    let buttonHeight = 52.0
+                    let buttonFrame = CGRect(x: floorToScreenPixels((params.width - buttonWidth) / 2.0), y: contentSize.height - buttonHeight + 4.0, width: buttonWidth, height: buttonHeight)
+                    strongSelf.buttonNode.frame = buttonFrame
+                    
+                    let _ = strongSelf.button.update(
+                        transition: .immediate,
+                        component: AnyComponent(ButtonComponent(
+                            background: ButtonComponent.Background(
+                                style: .glass,
+                                color: item.theme.list.itemCheckColors.fillColor,
+                                foreground: item.theme.list.itemCheckColors.foregroundColor,
+                                pressedColor: item.theme.list.itemCheckColors.fillColor.withMultipliedAlpha(0.9)
+                            ),
+                            content: AnyComponentWithIdentity(
+                                id: "button",
+                                component: AnyComponent(
+                                    HStack([
+                                        AnyComponentWithIdentity(id: "icon", component: AnyComponent(BundleIconComponent(name: "Settings/QrButtonIcon", tintColor: item.theme.list.itemCheckColors.foregroundColor))),
+                                        AnyComponentWithIdentity(id: "label", component: AnyComponent(
+                                            Text(text: item.context.sharedContext.currentPresentationData.with { $0 }.strings.AuthSessions_LinkDesktopDevice, font: Font.semibold(17.0), color: item.theme.list.itemCheckColors.foregroundColor)
+                                        ))
+                                    ], spacing: 6.0)
+                                )
+                            ),
+                            action: {
+                                item.buttonAction()
+                            }
+                        )),
+                        environment: {},
+                        containerSize: CGSize(width: buttonWidth, height: buttonHeight)
+                    )
+                    if let buttonView = strongSelf.button.view {
+                        if buttonView.superview == nil {
+                            strongSelf.view.addSubview(buttonView)
+                        }
+                        buttonView.frame = buttonFrame
+                    }
+                    
+                    strongSelf.accessibilityLabel = attributedText.string
+                                        
+                    let iconSize = CGSize(width: 128.0, height: 128.0)
+                    strongSelf.animationNode.frame = CGRect(origin: CGPoint(x: floor((layout.size.width - iconSize.width) / 2.0), y: -10.0), size: iconSize)
+                    strongSelf.animationNode.updateLayout(size: iconSize)
+                    
+                    let _ = titleApply()
+                    strongSelf.titleNode.frame = CGRect(origin: CGPoint(x: floor((layout.size.width - titleLayout.size.width) / 2.0), y: topInset + 8.0), size: titleLayout.size)
+                }
+            })
+        }
+    }
+    
+    override func animateInsertion(_ currentTimestamp: Double, duration: Double, options: ListViewItemAnimationOptions) {
+        self.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.4)
+    }
+    
+    override func animateRemoved(_ currentTimestamp: Double, duration: Double) {
+        self.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.15, removeOnCompletion: false)
+    }
+    
+    @objc private func tapLongTapOrDoubleTapGesture(_ recognizer: TapLongTapOrDoubleTapGestureRecognizer) {
+        switch recognizer.state {
+            case .ended:
+                if let (gesture, location) = recognizer.lastRecognizedGestureAndLocation {
+                    switch gesture {
+                        case .tap:
+                            if let item = self.item {
+                                if let (_, attributes) = self.titleNode.attributesAtPoint(location) {
+                                    if let url = attributes[NSAttributedString.Key(rawValue: TelegramTextAttributes.URL)] as? String {
+                                        item.linkAction?(.tap(url))
+                                    }
+                                }
+                            }
+                        default:
+                            break
+                    }
+                }
+            default:
+                break
+        }
+    }
+}