Merge commit '7621e2f8dec938cf48181c8b10afc9b01f444e68' into beta

submodules/SettingsUI/Sources/Data and Storage/AutodownloadConnectionTypeController.swift

@@ -0,0 +1,383 @@
+import Foundation
+import UIKit
+import Display
+import SwiftSignalKit
+import TelegramCore
+import TelegramPresentationData
+import TelegramUIPreferences
+import ItemListUI
+import PresentationDataUtils
+import AccountContext
+
+enum AutomaticDownloadConnectionType {
+    case cellular
+    case wifi
+    
+    var automaticDownloadNetworkType: MediaAutoDownloadNetworkType {
+        switch self {
+            case .cellular:
+                return .cellular
+            case .wifi:
+                return .wifi
+        }
+    }
+}
+
+private final class AutodownloadMediaConnectionTypeControllerArguments {
+    let toggleMaster: (Bool) -> Void
+    let changePreset: (AutomaticDownloadDataUsage) -> Void
+    let customize: (AutomaticDownloadCategory) -> Void
+    
+    init(toggleMaster: @escaping (Bool) -> Void, changePreset: @escaping (AutomaticDownloadDataUsage) -> Void, customize: @escaping (AutomaticDownloadCategory) -> Void) {
+        self.toggleMaster = toggleMaster
+        self.changePreset = changePreset
+        self.customize = customize
+    }
+}
+
+private enum AutodownloadMediaCategorySection: Int32 {
+    case master
+    case dataUsage
+    case types
+}
+
+private enum AutodownloadMediaCategoryEntry: ItemListNodeEntry {
+    case master(PresentationTheme, String, Bool)
+    case dataUsageHeader(PresentationTheme, String)
+    case dataUsageItem(PresentationTheme, PresentationStrings, AutomaticDownloadDataUsage, Int?, Bool)
+    case typesHeader(PresentationTheme, String)
+    case photos(PresentationTheme, String, String, Bool)
+    case stories(PresentationTheme, String, String, Bool)
+    case videos(PresentationTheme, String, String, Bool)
+    case files(PresentationTheme, String, String, Bool)
+    case voiceMessagesInfo(PresentationTheme, String)
+    
+    var section: ItemListSectionId {
+        switch self {
+            case .master:
+                return AutodownloadMediaCategorySection.master.rawValue
+            case .dataUsageHeader, .dataUsageItem:
+                return AutodownloadMediaCategorySection.dataUsage.rawValue
+            case .typesHeader, .photos, .stories, .videos, .files, .voiceMessagesInfo:
+                return AutodownloadMediaCategorySection.types.rawValue
+        }
+    }
+    
+    var stableId: Int32 {
+        switch self {
+            case .master:
+                return 0
+            case .dataUsageHeader:
+                return 1
+            case .dataUsageItem:
+                return 2
+            case .typesHeader:
+                return 3
+            case .photos:
+                return 4
+            case .stories:
+                return 5
+            case .videos:
+                return 6
+            case .files:
+                return 7
+            case .voiceMessagesInfo:
+                return 8
+        }
+    }
+    
+    static func ==(lhs: AutodownloadMediaCategoryEntry, rhs: AutodownloadMediaCategoryEntry) -> Bool {
+        switch lhs {
+            case let .master(lhsTheme, lhsText, lhsValue):
+                if case let .master(rhsTheme, rhsText, rhsValue) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue {
+                    return true
+                } else {
+                    return false
+                }
+            case let .dataUsageHeader(lhsTheme, lhsText):
+                if case let .dataUsageHeader(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .dataUsageItem(lhsTheme, lhsStrings, lhsValue, lhsCustomPosition, lhsEnabled):
+                if case let .dataUsageItem(rhsTheme, rhsStrings, rhsValue, rhsCustomPosition, rhsEnabled) = rhs, lhsTheme === rhsTheme, lhsStrings == rhsStrings, lhsValue == rhsValue, lhsCustomPosition == rhsCustomPosition, lhsEnabled == rhsEnabled {
+                    return true
+                } else {
+                    return false
+                }
+            case let .typesHeader(lhsTheme, lhsText):
+                if case let .typesHeader(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .photos(lhsTheme, lhsText, lhsValue, lhsEnabled):
+                if case let .photos(rhsTheme, rhsText, rhsValue, rhsEnabled) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue, lhsEnabled == rhsEnabled {
+                    return true
+                } else {
+                    return false
+                }
+            case let .stories(lhsTheme, lhsText, lhsValue, lhsEnabled):
+                if case let .stories(rhsTheme, rhsText, rhsValue, rhsEnabled) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue, lhsEnabled == rhsEnabled {
+                    return true
+                } else {
+                    return false
+                }
+            case let .videos(lhsTheme, lhsText, lhsValue, lhsEnabled):
+                if case let .videos(rhsTheme, rhsText, rhsValue, rhsEnabled) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue, lhsEnabled == rhsEnabled {
+                    return true
+                } else {
+                    return false
+                }
+            case let .files(lhsTheme, lhsText, lhsValue, lhsEnabled):
+                if case let .files(rhsTheme, rhsText, rhsValue, rhsEnabled) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue, lhsEnabled == rhsEnabled {
+                    return true
+                } else {
+                    return false
+                }
+            case let .voiceMessagesInfo(lhsTheme, lhsText):
+                if case let .voiceMessagesInfo(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+        }
+    }
+    
+    static func <(lhs: AutodownloadMediaCategoryEntry, rhs: AutodownloadMediaCategoryEntry) -> Bool {
+        return lhs.stableId < rhs.stableId
+    }
+    
+    func item(presentationData: ItemListPresentationData, arguments: Any) -> ListViewItem {
+        let arguments = arguments as! AutodownloadMediaConnectionTypeControllerArguments
+        switch self {
+            case let .master(_, text, value):
+                return ItemListSwitchItem(presentationData: presentationData, systemStyle: .glass, title: text, value: value, enableInteractiveChanges: true, enabled: true, sectionId: self.section, style: .blocks, updated: { value in
+                    arguments.toggleMaster(value)
+                })
+            case let .dataUsageHeader(_, text):
+                return ItemListSectionHeaderItem(presentationData: presentationData, text: text, sectionId: self.section)
+            case let .dataUsageItem(theme, strings, value, customPosition, enabled):
+                return AutodownloadDataUsagePickerItem(theme: theme, strings: strings, systemStyle: .glass, value: value, customPosition: customPosition, enabled: enabled, sectionId: self.section, updated: { preset in
+                    arguments.changePreset(preset)
+                })
+            case let .typesHeader(_, text):
+                return ItemListSectionHeaderItem(presentationData: presentationData, text: text, sectionId: self.section)
+            case let .photos(_, text, value, enabled):
+                return ItemListDisclosureItem(presentationData: presentationData, systemStyle: .glass, icon: UIImage(bundleImageName: "Settings/Menu/Photos")?.precomposed(), title: text, enabled: enabled, label: value, labelStyle: .detailText, sectionId: self.section, style: .blocks, action: {
+                    arguments.customize(.photo)
+                })
+            case let .stories(_, text, value, enabled):
+                return ItemListDisclosureItem(presentationData: presentationData, systemStyle: .glass, icon: UIImage(bundleImageName: "Settings/Menu/Stories")?.precomposed(), title: text, enabled: enabled, label: value, labelStyle: .detailText, sectionId: self.section, style: .blocks, action: {
+                    arguments.customize(.story)
+                })
+            case let .videos(_, text, value, enabled):
+                return ItemListDisclosureItem(presentationData: presentationData, systemStyle: .glass, icon: UIImage(bundleImageName: "Settings/Menu/Videos")?.precomposed(), title: text, enabled: enabled, label: value, labelStyle: .detailText, sectionId: self.section, style: .blocks, action: {
+                    arguments.customize(.video)
+                })
+            case let .files(_, text, value, enabled):
+                return ItemListDisclosureItem(presentationData: presentationData, systemStyle: .glass, icon: UIImage(bundleImageName: "Settings/Menu/Files")?.precomposed(), title: text, enabled: enabled, label: value, labelStyle: .detailText, sectionId: self.section, style: .blocks, action: {
+                    arguments.customize(.file)
+                })
+            case let .voiceMessagesInfo(_, text):
+                return ItemListTextItem(presentationData: presentationData, text: .plain(text), sectionId: self.section)
+        }
+    }
+}
+
+private struct AutomaticDownloadPeers {
+    let contacts: Bool
+    let otherPrivate: Bool
+    let groups: Bool
+    let channels: Bool
+    let size: Int64?
+    
+    init(category: MediaAutoDownloadCategory) {
+        self.contacts = category.contacts
+        self.otherPrivate = category.otherPrivate
+        self.groups = category.groups
+        self.channels = category.channels
+        self.size = category.sizeLimit
+    }
+}
+
+private func stringForAutomaticDownloadPeers(strings: PresentationStrings, decimalSeparator: String, peers: AutomaticDownloadPeers, category: AutomaticDownloadCategory) -> String {
+    if case .story = category {
+        if peers.contacts && peers.otherPrivate {
+            return strings.AutoDownloadSettings_OnForAll
+        } else if peers.contacts {
+            return strings.AutoDownloadSettings_OnForContacts
+        } else {
+            return strings.AutoDownloadSettings_OffForAll
+        }
+    }
+    
+    var size: String?
+    if var peersSize = peers.size, category == .video || category == .file {
+        if peersSize == Int32.max {
+            peersSize = 1536 * 1024 * 1024
+        }
+        size = autodownloadDataSizeString(Int64(peersSize), decimalSeparator: decimalSeparator)
+    }
+    
+    if peers.contacts && peers.otherPrivate && peers.groups && peers.channels {
+        if let size = size {
+            return strings.AutoDownloadSettings_UpToForAll(size).string
+        } else {
+            return strings.AutoDownloadSettings_OnForAll
+        }
+    } else {
+        var types: [String] = []
+        if peers.contacts {
+            types.append(strings.AutoDownloadSettings_TypeContacts)
+        }
+        if peers.otherPrivate {
+            types.append(strings.AutoDownloadSettings_TypePrivateChats)
+        }
+        if peers.groups {
+            types.append(strings.AutoDownloadSettings_TypeGroupChats)
+        }
+        if peers.channels {
+            types.append(strings.AutoDownloadSettings_TypeChannels)
+        }
+    
+        if types.isEmpty {
+            return strings.AutoDownloadSettings_OffForAll
+        }
+        
+        var string: String = ""
+        for i in 0 ..< types.count {
+            if !string.isEmpty {
+                if i == types.count - 1 {
+                    string.append(strings.AutoDownloadSettings_LastDelimeter)
+                } else {
+                    string.append(strings.AutoDownloadSettings_Delimeter)
+                }
+            }
+            string.append(types[i])
+        }
+        
+        if let size = size {
+            return strings.AutoDownloadSettings_UpToFor(size, string).string
+        } else {
+            return strings.AutoDownloadSettings_OnFor(string).string
+        }
+    }
+}
+
+private func autodownloadMediaConnectionTypeControllerEntries(presentationData: PresentationData, connectionType: AutomaticDownloadConnectionType, settings: MediaAutoDownloadSettings) -> [AutodownloadMediaCategoryEntry] {
+    var entries: [AutodownloadMediaCategoryEntry] = []
+    
+    let connection = settings.connectionSettings(for: connectionType.automaticDownloadNetworkType)
+    let categories = effectiveAutodownloadCategories(settings: settings, networkType: connectionType.automaticDownloadNetworkType)
+    
+    let master = connection.enabled
+    let photo = AutomaticDownloadPeers(category: categories.photo)
+    let video = AutomaticDownloadPeers(category: categories.video)
+    let file = AutomaticDownloadPeers(category: categories.file)
+    let stories = AutomaticDownloadPeers(category: categories.stories)
+    
+    entries.append(.master(presentationData.theme, presentationData.strings.AutoDownloadSettings_AutoDownload, master))
+    
+    entries.append(.dataUsageHeader(presentationData.theme, presentationData.strings.AutoDownloadSettings_DataUsage))
+    
+    var customPosition: Int?
+    if let custom = connection.custom {
+        let sortedPresets = [settings.presets.low, settings.presets.medium, settings.presets.high, custom].sorted()
+        customPosition = sortedPresets.firstIndex(of: custom) ?? 0
+    }
+    
+    entries.append(.dataUsageItem(presentationData.theme, presentationData.strings, AutomaticDownloadDataUsage(preset: connection.preset), customPosition, master))
+    
+    entries.append(.typesHeader(presentationData.theme, presentationData.strings.AutoDownloadSettings_MediaTypes))
+    entries.append(.photos(presentationData.theme, presentationData.strings.AutoDownloadSettings_Photos, stringForAutomaticDownloadPeers(strings: presentationData.strings, decimalSeparator: presentationData.dateTimeFormat.decimalSeparator, peers: photo, category: .photo), master))
+    entries.append(.stories(presentationData.theme, presentationData.strings.AutoDownloadSettings_Stories, stringForAutomaticDownloadPeers(strings: presentationData.strings, decimalSeparator: presentationData.dateTimeFormat.decimalSeparator, peers: stories, category: .story), master))
+    entries.append(.videos(presentationData.theme, presentationData.strings.AutoDownloadSettings_Videos, stringForAutomaticDownloadPeers(strings: presentationData.strings, decimalSeparator: presentationData.dateTimeFormat.decimalSeparator, peers: video, category: .video), master))
+    entries.append(.files(presentationData.theme, presentationData.strings.AutoDownloadSettings_Files, stringForAutomaticDownloadPeers(strings: presentationData.strings, decimalSeparator: presentationData.dateTimeFormat.decimalSeparator, peers: file, category: .file), master))
+    entries.append(.voiceMessagesInfo(presentationData.theme, presentationData.strings.AutoDownloadSettings_VoiceMessagesInfo))
+    
+    return entries
+}
+
+func autodownloadMediaConnectionTypeController(context: AccountContext, connectionType: AutomaticDownloadConnectionType) -> ViewController {
+    var pushControllerImpl: ((ViewController) -> Void)?
+    
+    let arguments = AutodownloadMediaConnectionTypeControllerArguments(toggleMaster: { value in
+        let _ = updateMediaDownloadSettingsInteractively(accountManager: context.sharedContext.accountManager, { settings in
+            var settings = settings
+            switch connectionType {
+                case .cellular:
+                    settings.cellular.enabled = value
+                case .wifi:
+                    settings.wifi.enabled = value
+            }
+            return settings
+        }).start()
+    }, changePreset: { value in
+        let _ = updateMediaDownloadSettingsInteractively(accountManager: context.sharedContext.accountManager, { settings in
+            var settings = settings
+            let preset: MediaAutoDownloadPreset
+            switch value {
+                case .low:
+                    preset = .low
+                case .medium:
+                    preset = .medium
+                case .high:
+                    preset = .high
+                case .custom:
+                    preset = .custom
+            }
+            switch connectionType {
+                case .cellular:
+                    settings.cellular.preset = preset
+                case .wifi:
+                    settings.wifi.preset = preset
+            }
+            return settings
+        }).start()
+    }, customize: { category in
+        let controller = autodownloadMediaCategoryController(context: context, connectionType: connectionType, category: category)
+        pushControllerImpl?(controller)
+    })
+    
+    let signal = combineLatest(context.sharedContext.presentationData, context.sharedContext.accountManager.sharedData(keys: [SharedDataKeys.autodownloadSettings, ApplicationSpecificSharedDataKeys.automaticMediaDownloadSettings]))
+        |> deliverOnMainQueue
+        |> map { presentationData, sharedData -> (ItemListControllerState, (ItemListNodeState, Any)) in
+            var automaticMediaDownloadSettings: MediaAutoDownloadSettings
+            if let value = sharedData.entries[ApplicationSpecificSharedDataKeys.automaticMediaDownloadSettings]?.get(MediaAutoDownloadSettings.self) {
+                automaticMediaDownloadSettings = value
+            } else {
+                automaticMediaDownloadSettings = MediaAutoDownloadSettings.defaultSettings
+            }
+            
+            var autodownloadSettings: AutodownloadSettings
+            if let value = sharedData.entries[SharedDataKeys.autodownloadSettings]?.get(AutodownloadSettings.self) {
+                autodownloadSettings = value
+                automaticMediaDownloadSettings = automaticMediaDownloadSettings.updatedWithAutodownloadSettings(autodownloadSettings)
+            } else {
+                autodownloadSettings = .defaultSettings
+            }
+            
+            let title: String
+            switch connectionType {
+                case .cellular:
+                    title = presentationData.strings.AutoDownloadSettings_CellularTitle
+                case .wifi:
+                    title = presentationData.strings.AutoDownloadSettings_WifiTitle
+            }
+            
+            let controllerState = ItemListControllerState(presentationData: ItemListPresentationData(presentationData), title: .text(title), leftNavigationButton: nil, rightNavigationButton: nil, backNavigationButton: ItemListBackButton(title: presentationData.strings.Common_Back), animateChanges: false)
+            let listState = ItemListNodeState(presentationData: ItemListPresentationData(presentationData), entries: autodownloadMediaConnectionTypeControllerEntries(presentationData: presentationData, connectionType: connectionType, settings: automaticMediaDownloadSettings), style: .blocks, emptyStateItem: nil, animateChanges: false)
+            
+            return (controllerState, (listState, arguments))
+    }
+    
+    let controller = ItemListController(context: context, state: signal)
+    pushControllerImpl = { [weak controller] c in
+        if let controller = controller {
+            (controller.navigationController as? NavigationController)?.pushViewController(c)
+        }
+    }
+    return controller
+}

submodules/SettingsUI/Sources/Data and Storage/AutodownloadDataUsagePickerItem.swift

@@ -0,0 +1,353 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import TelegramCore
+import TelegramUIPreferences
+import TelegramPresentationData
+import ItemListUI
+import PresentationDataUtils
+import ComponentFlow
+import SliderComponent
+
+enum AutomaticDownloadDataUsage: Int {
+    case low
+    case medium
+    case high
+    case custom
+    
+    init(preset: MediaAutoDownloadPreset) {
+        switch preset {
+            case .low:
+                self = .low
+            case .medium:
+                self = .medium
+            case .high:
+                self = .high
+            case .custom:
+                self = .custom
+        }
+    }
+}
+
+final class AutodownloadDataUsagePickerItem: ListViewItem, ItemListItem {
+    let theme: PresentationTheme
+    let strings: PresentationStrings
+    let systemStyle: ItemListSystemStyle
+    let value: AutomaticDownloadDataUsage
+    let customPosition: Int?
+    let enabled: Bool
+    let sectionId: ItemListSectionId
+    let updated: (AutomaticDownloadDataUsage) -> Void
+    
+    init(theme: PresentationTheme, strings: PresentationStrings, systemStyle: ItemListSystemStyle = .legacy, value: AutomaticDownloadDataUsage, customPosition: Int?, enabled: Bool, sectionId: ItemListSectionId, updated: @escaping (AutomaticDownloadDataUsage) -> Void) {
+        self.theme = theme
+        self.strings = strings
+        self.systemStyle = systemStyle
+        self.value = value
+        self.customPosition = customPosition
+        self.enabled = enabled
+        self.sectionId = sectionId
+        self.updated = updated
+    }
+    
+    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 = AutodownloadDataUsagePickerItemNode()
+            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 {
+            if let nodeValue = node() as? AutodownloadDataUsagePickerItemNode {
+                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 final class AutodownloadDataUsagePickerItemNode: ListViewItemNode {
+    private let backgroundNode: ASDisplayNode
+    private let topStripeNode: ASDisplayNode
+    private let bottomStripeNode: ASDisplayNode
+    private let maskNode: ASImageNode
+    
+    private let lowTextNode: TextNode
+    private let mediumTextNode: TextNode
+    private let highTextNode: TextNode
+    private let customTextNode: TextNode
+    private let slider = ComponentView<Empty>()
+    
+    private let activateArea: AccessibilityAreaNode
+    
+    private var item: AutodownloadDataUsagePickerItem?
+    private var layoutParams: ListViewItemLayoutParams?
+    
+    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.lowTextNode = TextNode()
+        self.lowTextNode.isUserInteractionEnabled = false
+        self.lowTextNode.displaysAsynchronously = false
+        
+        self.mediumTextNode = TextNode()
+        self.mediumTextNode.isUserInteractionEnabled = false
+        self.mediumTextNode.displaysAsynchronously = false
+        
+        self.highTextNode = TextNode()
+        self.highTextNode.isUserInteractionEnabled = false
+        self.highTextNode.displaysAsynchronously = false
+      
+        self.customTextNode = TextNode()
+        self.customTextNode.isUserInteractionEnabled = false
+        self.customTextNode.displaysAsynchronously = false
+        
+        self.activateArea = AccessibilityAreaNode()
+        
+        super.init(layerBacked: false, dynamicBounce: false)
+        
+        self.addSubnode(self.lowTextNode)
+        self.addSubnode(self.mediumTextNode)
+        self.addSubnode(self.highTextNode)
+        self.addSubnode(self.customTextNode)
+        self.addSubnode(self.activateArea)
+        
+//        self.activateArea.increment = { [weak self] in
+//            if let self {
+//                self.sliderView?.increase()
+//            }
+//        }
+//        
+//        self.activateArea.decrement = { [weak self] in
+//            if let self {
+//                self.sliderView?.decrease()
+//            }
+//        }
+    }
+    
+    func asyncLayout() -> (_ item: AutodownloadDataUsagePickerItem, _ params: ListViewItemLayoutParams, _ neighbors: ItemListNeighbors) -> (ListViewItemNodeLayout, () -> Void) {
+        let makeLowTextLayout = TextNode.asyncLayout(self.lowTextNode)
+        let makeMediumTextLayout = TextNode.asyncLayout(self.mediumTextNode)
+        let makeHighTextLayout = TextNode.asyncLayout(self.highTextNode)
+        let makeCustomTextLayout = TextNode.asyncLayout(self.customTextNode)
+        
+        return { item, params, neighbors in
+            let contentSize: CGSize
+            let insets: UIEdgeInsets
+            let separatorHeight = UIScreenPixel
+            
+            let (lowTextLayout, lowTextApply) = makeLowTextLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: item.strings.AutoDownloadSettings_DataUsageLow, font: Font.regular(13.0), textColor: item.theme.list.itemSecondaryTextColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width, height: CGFloat.greatestFiniteMagnitude), alignment: .center, lineSpacing: 0.0, cutout: nil, insets: UIEdgeInsets()))
+
+            let (mediumTextLayout, mediumTextApply) = makeMediumTextLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: item.strings.AutoDownloadSettings_DataUsageMedium, font: Font.regular(13.0), textColor: item.theme.list.itemSecondaryTextColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width, height: CGFloat.greatestFiniteMagnitude), alignment: .center, lineSpacing: 0.0, cutout: nil, insets: UIEdgeInsets()))
+            
+            let (highTextLayout, highTextApply) = makeHighTextLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: item.strings.AutoDownloadSettings_DataUsageHigh, font: Font.regular(13.0), textColor: item.theme.list.itemSecondaryTextColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width, height: CGFloat.greatestFiniteMagnitude), alignment: .center, lineSpacing: 0.0, cutout: nil, insets: UIEdgeInsets()))
+            
+            let (customTextLayout, customTextApply) = makeCustomTextLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: item.strings.AutoDownloadSettings_DataUsageCustom, font: Font.regular(13.0), textColor: item.theme.list.itemSecondaryTextColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width, height: CGFloat.greatestFiniteMagnitude), alignment: .center, lineSpacing: 0.0, cutout: nil, insets: UIEdgeInsets()))
+            
+            contentSize = CGSize(width: params.width, height: 88.0)
+            insets = itemListNeighborsGroupedInsets(neighbors, params)
+            
+            let layout = ListViewItemNodeLayout(contentSize: contentSize, insets: insets)
+            let layoutSize = layout.size
+            
+            return (layout, { [weak self] in
+                if let strongSelf = self {
+                    strongSelf.item = item
+                    strongSelf.layoutParams = params
+                    
+                    strongSelf.backgroundNode.backgroundColor = item.theme.list.itemBlocksBackgroundColor
+                    strongSelf.topStripeNode.backgroundColor = item.theme.list.itemBlocksSeparatorColor
+                    strongSelf.bottomStripeNode.backgroundColor = item.theme.list.itemBlocksSeparatorColor
+                    
+                    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.insertSubnode(strongSelf.maskNode, at: 3)
+                    }
+                    
+                    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 = 0.0 //params.leftInset + 16.0
+                        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.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.maskNode.frame = strongSelf.backgroundNode.frame.insetBy(dx: params.leftInset, dy: 0.0)
+                    strongSelf.topStripeNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: layoutSize.width, height: separatorHeight))
+                    strongSelf.bottomStripeNode.frame = CGRect(origin: CGPoint(x: bottomStripeInset, y: contentSize.height + bottomStripeOffset), size: CGSize(width: layoutSize.width - bottomStripeInset, height: separatorHeight))
+                    
+                    let _ = lowTextApply()
+                    let _ = mediumTextApply()
+                    let _ = highTextApply()
+                    let _ = customTextApply()
+                    
+                    var textNodes: [(TextNode, CGSize)] = [(strongSelf.lowTextNode, lowTextLayout.size),
+                                                           (strongSelf.mediumTextNode, mediumTextLayout.size),
+                                                           (strongSelf.highTextNode, highTextLayout.size)]
+                    if let customPosition = item.customPosition {
+                        textNodes.insert((strongSelf.customTextNode, customTextLayout.size), at: customPosition)
+                    }
+                    
+                    let delta = (params.width - params.leftInset - params.rightInset - 25.0 * 2.0) / CGFloat(textNodes.count - 1)
+                    for i in 0 ..< textNodes.count {
+                        let (textNode, textSize) = textNodes[i]
+                        
+                        let leftEdge = params.leftInset + 18.0
+                        let rightEdge = params.width - params.rightInset - 18.0
+                        let position = params.leftInset + 25.0 + delta * CGFloat(i)
+                        let origin = max(leftEdge, min(rightEdge - textSize.width, position - textSize.width / 2.0))
+                        
+                        textNode.frame = CGRect(origin: CGPoint(x: origin, y: 15.0), size: textSize)
+                    }
+                    
+                    
+                    var valueCount = 3
+                    var value = item.value.rawValue
+                    if let customPosition = item.customPosition {
+                        valueCount += 1
+                        if case .custom = item.value {
+                            value = customPosition
+                        } else {
+                            if value >= customPosition {
+                                value += 1
+                            }
+                        }
+                    }
+                    
+                    let sliderSize = strongSelf.slider.update(
+                        transition: .immediate,
+                        component: AnyComponent(
+                            SliderComponent(
+                                content: .discrete(.init(
+                                    valueCount: valueCount,
+                                    value: value,
+                                    markPositions: true,
+                                    valueUpdated: { [weak self] position in
+                                        guard let self else {
+                                            return
+                                        }
+                                        var value: AutomaticDownloadDataUsage?
+                                        if let customPosition = self.item?.customPosition {
+                                            if position == customPosition {
+                                                value = .custom
+                                            } else {
+                                                value = AutomaticDownloadDataUsage(rawValue: position > customPosition ? (position - 1) : position)
+                                            }
+                                        } else {
+                                            value = AutomaticDownloadDataUsage(rawValue: position)
+                                        }
+                                        if let value = value {
+                                            self.item?.updated(value)
+                                        }
+                                    }
+                                )),
+                                useNative: true,
+                                trackBackgroundColor: item.theme.list.itemSwitchColors.frameColor,
+                                trackForegroundColor: item.theme.list.itemAccentColor
+                            )
+                        ),
+                        environment: {},
+                        containerSize: CGSize(width: params.width - params.leftInset - params.rightInset - 15.0 * 2.0, height: 44.0)
+                    )
+                    if let sliderView = strongSelf.slider.view {
+                        if sliderView.superview == nil {
+                            strongSelf.view.addSubview(sliderView)
+                        }
+                        sliderView.frame = CGRect(origin: CGPoint(x: floorToScreenPixels((params.width - sliderSize.width) / 2.0), y: 37.0), size: sliderSize)
+                        sliderView.isUserInteractionEnabled = item.enabled
+                        sliderView.alpha = item.enabled ? 1.0 : 0.4
+                        sliderView.layer.allowsGroupOpacity = !item.enabled
+                    }
+                    
+                    strongSelf.activateArea.accessibilityLabel = item.strings.AutoDownloadSettings_DataUsage
+                    
+                    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))
+                }
+            })
+        }
+    }
+    
+    private func updateAccessibilityLabels() {
+//        guard let item = self.item else {
+//            return
+//        }
+//        var textNodes: [TextNode] = [self.lowTextNode, self.mediumTextNode, self.highTextNode]
+//        if let customPosition = item.customPosition {
+//            textNodes.insert(self.customTextNode, at: customPosition)
+//        }
+//        if let value = self.sliderView?.value {
+//            self.activateArea.accessibilityValue = textNodes[Int(value)].cachedLayout?.attributedString?.string ?? ""
+//        }
+//        var accessibilityTraits: UIAccessibilityTraits = [.adjustable]
+//        if item.enabled {
+//        } else {
+//            accessibilityTraits.insert(.notEnabled)
+//        }
+//        self.activateArea.accessibilityTraits = accessibilityTraits
+    }
+    
+    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)
+    }
+}
+

submodules/SettingsUI/Sources/Data and Storage/AutodownloadMediaCategoryController.swift

@@ -0,0 +1,502 @@
+import Foundation
+import UIKit
+import Display
+import SwiftSignalKit
+import TelegramCore
+import TelegramPresentationData
+import TelegramUIPreferences
+import ItemListUI
+import PresentationDataUtils
+import AccountContext
+
+public func autodownloadDataSizeString(_ size: Int64, decimalSeparator: String = ".") -> String {
+    if size >= 1024 * 1024 * 1024 {
+        var remainder = (size % (1024 * 1024 * 1024)) / (1024 * 1024 * 102)
+        if remainder == 10 {
+            remainder = 9
+        }
+        while remainder != 0 && remainder % 10 == 0 {
+            remainder /= 10
+        }
+        
+        if remainder != 0 {
+            return "\(size / (1024 * 1024 * 1024))\(decimalSeparator)\(remainder) GB"
+        } else {
+            return "\(size / (1024 * 1024 * 1024)) GB"
+        }
+    } else if size >= 1024 * 1024 {
+        var remainder = (size % (1024 * 1024)) / (1024 * 102)
+        if remainder == 10 {
+            remainder = 9
+        }
+        while remainder != 0 && remainder % 10 == 0 {
+            remainder /= 10
+        }
+        
+        if size < 10 * 1024 * 1024 {
+            return "\(size / (1024 * 1024))\(decimalSeparator)\(remainder) MB"
+        } else {
+            return "\(size / (1024 * 1024)) MB"
+        }
+    } else if size >= 1024 {
+        return "\(size / 1024) KB"
+    } else {
+        return "\(size) B"
+    }
+}
+
+enum AutomaticDownloadCategory {
+    case photo
+    case video
+    case file
+    case story
+}
+
+private enum AutomaticDownloadPeerType {
+    case contact
+    case otherPrivate
+    case group
+    case channel
+}
+
+private final class AutodownloadMediaCategoryControllerArguments {
+    let togglePeer: (AutomaticDownloadPeerType) -> Void
+    let adjustSize: (Int64) -> Void
+    let toggleVideoPreload: () -> Void
+    
+    init(togglePeer: @escaping (AutomaticDownloadPeerType) -> Void, adjustSize: @escaping (Int64) -> Void, toggleVideoPreload: @escaping () -> Void) {
+        self.togglePeer = togglePeer
+        self.adjustSize = adjustSize
+        self.toggleVideoPreload = toggleVideoPreload
+    }
+}
+
+private enum AutodownloadMediaCategorySection: Int32 {
+    case peer
+    case size
+}
+
+private enum AutodownloadMediaCategoryEntry: ItemListNodeEntry {
+    case peerHeader(PresentationTheme, String)
+    case peerContacts(PresentationTheme, String, Bool)
+    case peerOtherPrivate(PresentationTheme, String, Bool)
+    case peerGroups(PresentationTheme, String, Bool)
+    case peerChannels(PresentationTheme, String, Bool)
+    
+    case sizeHeader(PresentationTheme, String)
+    case sizeItem(PresentationTheme, PresentationStrings, String, String, Int64)
+    case sizePreload(PresentationTheme, String, Bool, Bool)
+    case sizePreloadInfo(PresentationTheme, String)
+    
+    var section: ItemListSectionId {
+        switch self {
+            case .peerHeader, .peerContacts, .peerOtherPrivate, .peerGroups, .peerChannels:
+                return AutodownloadMediaCategorySection.peer.rawValue
+            case .sizeHeader, .sizeItem, .sizePreload, .sizePreloadInfo:
+                return AutodownloadMediaCategorySection.size.rawValue
+        }
+    }
+    
+    var stableId: Int32 {
+        switch self {
+            case .peerHeader:
+                return 0
+            case .peerContacts:
+                return 1
+            case .peerOtherPrivate:
+                return 2
+            case .peerGroups:
+                return 3
+            case .peerChannels:
+                return 4
+            case .sizeHeader:
+                return 5
+            case .sizeItem:
+                return 6
+            case .sizePreload:
+                return 7
+            case .sizePreloadInfo:
+                return 8
+        }
+    }
+    
+    static func ==(lhs: AutodownloadMediaCategoryEntry, rhs: AutodownloadMediaCategoryEntry) -> Bool {
+        switch lhs {
+            case let .peerHeader(lhsTheme, lhsText):
+                if case let .peerHeader(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .peerContacts(lhsTheme, lhsText, lhsValue):
+                if case let .peerContacts(rhsTheme, rhsText, rhsValue) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue {
+                    return true
+                } else {
+                    return false
+                }
+            case let .peerOtherPrivate(lhsTheme, lhsText, lhsValue):
+                if case let .peerOtherPrivate(rhsTheme, rhsText, rhsValue) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue {
+                    return true
+                } else {
+                    return false
+                }
+            case let .peerGroups(lhsTheme, lhsText, lhsValue):
+                if case let .peerGroups(rhsTheme, rhsText, rhsValue) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue {
+                    return true
+                } else {
+                    return false
+                }
+            case let .peerChannels(lhsTheme, lhsText, lhsValue):
+                if case let .peerChannels(rhsTheme, rhsText, rhsValue) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue {
+                    return true
+                } else {
+                    return false
+                }
+            case let .sizeHeader(lhsTheme, lhsText):
+                if case let .sizeHeader(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .sizeItem(lhsTheme, lhsStrings, lhsDecimalSeparator, lhsText, lhsValue):
+                if case let .sizeItem(rhsTheme, rhsStrings, rhsDecimalSeparator, rhsText, rhsValue) = rhs, lhsTheme === rhsTheme, lhsStrings === rhsStrings, lhsDecimalSeparator == rhsDecimalSeparator, lhsText == rhsText, lhsValue == rhsValue {
+                    return true
+                } else {
+                    return false
+                }
+            case let .sizePreload(lhsTheme, lhsText, lhsValue, lhsEnabled):
+                if case let .sizePreload(rhsTheme, rhsText, rhsValue, rhsEnabled) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue, lhsEnabled == rhsEnabled {
+                    return true
+                } else {
+                    return false
+                }
+            case let .sizePreloadInfo(lhsTheme, lhsText):
+                if case let .sizePreloadInfo(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+        }
+    }
+    
+    static func <(lhs: AutodownloadMediaCategoryEntry, rhs: AutodownloadMediaCategoryEntry) -> Bool {
+        return lhs.stableId < rhs.stableId
+    }
+    
+    func item(presentationData: ItemListPresentationData, arguments: Any) -> ListViewItem {
+        let arguments = arguments as! AutodownloadMediaCategoryControllerArguments
+        switch self {
+            case let .peerHeader(_, text):
+                return ItemListSectionHeaderItem(presentationData: presentationData, text: text, sectionId: self.section)
+            case let .peerContacts(_, text, value):
+                return ItemListSwitchItem(presentationData: presentationData, systemStyle: .glass, title: text, value: value, enableInteractiveChanges: true, enabled: true, sectionId: self.section, style: .blocks, updated: { value in
+                    arguments.togglePeer(.contact)
+                })
+            case let .peerOtherPrivate(_, text, value):
+                return ItemListSwitchItem(presentationData: presentationData, systemStyle: .glass, title: text, value: value, enableInteractiveChanges: true, enabled: true, sectionId: self.section, style: .blocks, updated: { value in
+                    arguments.togglePeer(.otherPrivate)
+                })
+            case let .peerGroups(_, text, value):
+                return ItemListSwitchItem(presentationData: presentationData, systemStyle: .glass, title: text, value: value, enableInteractiveChanges: true, enabled: true, sectionId: self.section, style: .blocks, updated: { value in
+                    arguments.togglePeer(.group)
+                })
+            case let .peerChannels(_, text, value):
+                return ItemListSwitchItem(presentationData: presentationData, systemStyle: .glass, title: text, value: value, enableInteractiveChanges: true, enabled: true, sectionId: self.section, style: .blocks, updated: { value in
+                    arguments.togglePeer(.channel)
+                })
+            case let .sizeHeader(_, text):
+                return ItemListSectionHeaderItem(presentationData: presentationData, text: text, sectionId: self.section)
+            case let .sizeItem(theme, strings, decimalSeparator, text, value):
+                return AutodownloadSizeLimitItem(theme: theme, strings: strings, systemStyle: .glass, decimalSeparator: decimalSeparator, text: text, value: value, range: nil, sectionId: self.section, updated: { value in
+                    arguments.adjustSize(value)
+                })
+            case let .sizePreload(_, text, value, enabled):
+                return ItemListSwitchItem(presentationData: presentationData, systemStyle: .glass, title: text, value: value && enabled, enableInteractiveChanges: true, enabled: enabled, sectionId: self.section, style: .blocks, updated: { value in
+                    arguments.toggleVideoPreload()
+                })
+            case let .sizePreloadInfo(_, text):
+                return ItemListTextItem(presentationData: presentationData, text: .plain(text), sectionId: self.section)
+        }
+    }
+}
+
+private struct AutomaticDownloadPeers {
+    let contacts: Bool
+    let otherPrivate: Bool
+    let groups: Bool
+    let channels: Bool
+    
+    init(category: MediaAutoDownloadCategory) {
+        self.contacts = category.contacts
+        self.otherPrivate = category.otherPrivate
+        self.groups = category.groups
+        self.channels = category.channels
+    }
+}
+
+private func autodownloadMediaCategoryControllerEntries(presentationData: PresentationData, connectionType: AutomaticDownloadConnectionType, category: AutomaticDownloadCategory, settings: MediaAutoDownloadSettings) -> [AutodownloadMediaCategoryEntry] {
+    var entries: [AutodownloadMediaCategoryEntry] = []
+    
+    let categories = effectiveAutodownloadCategories(settings: settings, networkType: connectionType.automaticDownloadNetworkType)
+    
+    let peers: AutomaticDownloadPeers
+    let size: Int64
+    let predownload: Bool
+    
+    switch category {
+    case .photo:
+        peers = AutomaticDownloadPeers(category: categories.photo)
+        size = categories.photo.sizeLimit
+        predownload = categories.photo.predownload
+    case .video:
+        peers = AutomaticDownloadPeers(category: categories.video)
+        size = categories.video.sizeLimit
+        predownload = categories.video.predownload
+    case .file:
+        peers = AutomaticDownloadPeers(category: categories.file)
+        size = categories.file.sizeLimit
+        predownload = categories.file.predownload
+    case .story:
+        peers = AutomaticDownloadPeers(category: categories.stories)
+        size = categories.stories.sizeLimit
+        predownload = categories.stories.predownload
+    }
+    
+    let downloadTitle: String
+    var sizeTitle: String?
+    switch category {
+    case .photo:
+        downloadTitle = presentationData.strings.AutoDownloadSettings_AutodownloadPhotos
+    case .video:
+        downloadTitle = presentationData.strings.AutoDownloadSettings_AutodownloadVideos
+        sizeTitle = presentationData.strings.AutoDownloadSettings_MaxVideoSize
+    case .file:
+        downloadTitle = presentationData.strings.AutoDownloadSettings_AutodownloadFiles
+        sizeTitle = presentationData.strings.AutoDownloadSettings_MaxFileSize
+    case .story:
+        downloadTitle = presentationData.strings.AutoDownloadSettings_StoriesSectionHeader
+        sizeTitle = presentationData.strings.AutoDownloadSettings_MaxFileSize
+    }
+    
+    if case .story = category {
+        entries.append(.peerContacts(presentationData.theme, presentationData.strings.AutoDownloadSettings_Contacts, peers.contacts))
+        if peers.contacts {
+            entries.append(.peerOtherPrivate(presentationData.theme, presentationData.strings.AutoDownloadSettings_StoriesArchivedContacts, peers.otherPrivate))
+        }
+    } else {
+        entries.append(.peerHeader(presentationData.theme, downloadTitle))
+        entries.append(.peerContacts(presentationData.theme, presentationData.strings.AutoDownloadSettings_Contacts, peers.contacts))
+        entries.append(.peerOtherPrivate(presentationData.theme, presentationData.strings.AutoDownloadSettings_PrivateChats, peers.otherPrivate))
+        entries.append(.peerGroups(presentationData.theme, presentationData.strings.AutoDownloadSettings_GroupChats, peers.groups))
+        entries.append(.peerChannels(presentationData.theme, presentationData.strings.AutoDownloadSettings_Channels, peers.channels))
+    }
+    
+    switch category {
+        case .video, .file:
+            if let sizeTitle = sizeTitle {
+                entries.append(.sizeHeader(presentationData.theme, sizeTitle))
+            }
+            
+            let sizeText: String
+            if size == Int64.max {
+                sizeText = autodownloadDataSizeString(1536 * 1024 * 1024, decimalSeparator: presentationData.dateTimeFormat.decimalSeparator)
+            } else {
+                sizeText = autodownloadDataSizeString(Int64(size), decimalSeparator: presentationData.dateTimeFormat.decimalSeparator)
+            }
+            let text = presentationData.strings.AutoDownloadSettings_UpTo(sizeText).string
+            entries.append(.sizeItem(presentationData.theme, presentationData.strings, presentationData.dateTimeFormat.decimalSeparator, text, size))
+            if #available(iOSApplicationExtension 10.3, *), category == .video {
+                entries.append(.sizePreload(presentationData.theme, presentationData.strings.AutoDownloadSettings_PreloadVideo, predownload, size > 2 * 1024 * 1024))
+                entries.append(.sizePreloadInfo(presentationData.theme, presentationData.strings.AutoDownloadSettings_PreloadVideoInfo(sizeText).string))
+            }
+        default:
+            break
+    }
+    
+    return entries
+}
+
+func autodownloadMediaCategoryController(context: AccountContext, connectionType: AutomaticDownloadConnectionType, category: AutomaticDownloadCategory) -> ViewController {
+    let arguments = AutodownloadMediaCategoryControllerArguments(togglePeer: { type in
+        let _ = updateMediaDownloadSettingsInteractively(accountManager: context.sharedContext.accountManager, { settings in
+            var settings = settings
+            var categories = effectiveAutodownloadCategories(settings: settings, networkType: connectionType.automaticDownloadNetworkType)
+            switch category {
+                case .photo:
+                    switch type {
+                        case .contact:
+                            categories.photo.contacts = !categories.photo.contacts
+                        case .otherPrivate:
+                            categories.photo.otherPrivate = !categories.photo.otherPrivate
+                        case .group:
+                            categories.photo.groups = !categories.photo.groups
+                        case .channel:
+                            categories.photo.channels = !categories.photo.channels
+                    }
+                case .video:
+                    switch type {
+                        case .contact:
+                            categories.video.contacts = !categories.video.contacts
+                        case .otherPrivate:
+                            categories.video.otherPrivate = !categories.video.otherPrivate
+                        case .group:
+                            categories.video.groups = !categories.video.groups
+                        case .channel:
+                            categories.video.channels = !categories.video.channels
+                }
+                case .file:
+                    switch type {
+                        case .contact:
+                            categories.file.contacts = !categories.file.contacts
+                        case .otherPrivate:
+                            categories.file.otherPrivate = !categories.file.otherPrivate
+                        case .group:
+                            categories.file.groups = !categories.file.groups
+                        case .channel:
+                            categories.file.channels = !categories.file.channels
+                    }
+                case .story:
+                    switch type {
+                        case .contact:
+                            categories.stories.contacts = !categories.stories.contacts
+                        case .otherPrivate:
+                            categories.stories.otherPrivate = !categories.stories.otherPrivate
+                        case .group:
+                            categories.stories.groups = !categories.stories.groups
+                        case .channel:
+                            categories.stories.channels = !categories.stories.channels
+                    }
+            }
+            switch connectionType {
+                case .cellular:
+                    settings.cellular.preset = .custom
+                    settings.cellular.custom = categories
+                case .wifi:
+                    settings.wifi.preset = .custom
+                    settings.wifi.custom = categories
+            }
+            return settings
+        }).start()
+    }, adjustSize: { size in
+        let _ = updateMediaDownloadSettingsInteractively(accountManager: context.sharedContext.accountManager, { settings in
+            var settings = settings
+            var categories = effectiveAutodownloadCategories(settings: settings, networkType: connectionType.automaticDownloadNetworkType)
+            switch category {
+                case .photo:
+                    categories.photo.sizeLimit = size
+                case .video:
+                    categories.video.sizeLimit = size
+                case .file:
+                    categories.file.sizeLimit = size
+                case .story:
+                    categories.stories.sizeLimit = size
+            }
+            switch connectionType {
+                case .cellular:
+                    settings.cellular.preset = .custom
+                    settings.cellular.custom = categories
+                case .wifi:
+                    settings.wifi.preset = .custom
+                    settings.wifi.custom = categories
+            }
+            return settings
+        }).start()
+    }, toggleVideoPreload: {
+        let _ = updateMediaDownloadSettingsInteractively(accountManager: context.sharedContext.accountManager, { settings in
+            var settings = settings
+            var categories = effectiveAutodownloadCategories(settings: settings, networkType: connectionType.automaticDownloadNetworkType)
+            switch category {
+                case .photo:
+                    categories.photo.predownload = !categories.photo.predownload
+                case .video:
+                    categories.video.predownload = !categories.video.predownload
+                case .file:
+                    categories.file.predownload = !categories.file.predownload
+                case .story:
+                    categories.stories.predownload = !categories.stories.predownload
+            }
+            switch connectionType {
+                case .cellular:
+                    settings.cellular.preset = .custom
+                    settings.cellular.custom = categories
+                case .wifi:
+                    settings.wifi.preset = .custom
+                    settings.wifi.custom = categories
+            }
+            return settings
+        }).start()
+    })
+    
+    let currentAutodownloadSettings = {
+        return context.sharedContext.accountManager.sharedData(keys: [ApplicationSpecificSharedDataKeys.automaticMediaDownloadSettings])
+        |> take(1)
+        |> map { sharedData -> MediaAutoDownloadSettings in
+            if let value = sharedData.entries[ApplicationSpecificSharedDataKeys.automaticMediaDownloadSettings]?.get(MediaAutoDownloadSettings.self) {
+                return value
+            } else {
+                return .defaultSettings
+            }
+        }
+    }
+    
+    let initialValuePromise: Promise<MediaAutoDownloadSettings> = Promise()
+    initialValuePromise.set(currentAutodownloadSettings())
+    
+    let signal = combineLatest(context.sharedContext.presentationData, context.sharedContext.accountManager.sharedData(keys: [SharedDataKeys.autodownloadSettings, ApplicationSpecificSharedDataKeys.automaticMediaDownloadSettings])) |> deliverOnMainQueue
+        |> map { presentationData, sharedData -> (ItemListControllerState, (ItemListNodeState, Any)) in
+            var automaticMediaDownloadSettings: MediaAutoDownloadSettings
+            if let value = sharedData.entries[ApplicationSpecificSharedDataKeys.automaticMediaDownloadSettings]?.get(MediaAutoDownloadSettings.self) {
+                automaticMediaDownloadSettings = value
+            } else {
+                automaticMediaDownloadSettings = .defaultSettings
+            }
+            
+            var autodownloadSettings: AutodownloadSettings
+            if let value = sharedData.entries[SharedDataKeys.autodownloadSettings]?.get(AutodownloadSettings.self) {
+                autodownloadSettings = value
+                automaticMediaDownloadSettings = automaticMediaDownloadSettings.updatedWithAutodownloadSettings(autodownloadSettings)
+            } else {
+                autodownloadSettings = .defaultSettings
+            }
+            
+            let title: String
+            switch category {
+            case .photo:
+                title = presentationData.strings.AutoDownloadSettings_PhotosTitle
+            case .video:
+                title = presentationData.strings.AutoDownloadSettings_VideosTitle
+            case .file:
+                title = presentationData.strings.AutoDownloadSettings_DocumentsTitle
+            case .story:
+                title = presentationData.strings.AutoDownloadSettings_StoriesTitle
+            }
+            
+            let controllerState = ItemListControllerState(presentationData: ItemListPresentationData(presentationData), title: .text(title), leftNavigationButton: nil, rightNavigationButton: nil, backNavigationButton: ItemListBackButton(title: presentationData.strings.Common_Back), animateChanges: false)
+            let listState = ItemListNodeState(presentationData: ItemListPresentationData(presentationData), entries: autodownloadMediaCategoryControllerEntries(presentationData: presentationData, connectionType: connectionType, category: category, settings: automaticMediaDownloadSettings), style: .blocks, emptyStateItem: nil, animateChanges: true)
+            
+            return (controllerState, (listState, arguments))
+    }
+    
+    let controller = ItemListController(context: context, state: signal)
+    controller.didDisappear = { _ in
+        let _ = (combineLatest(initialValuePromise.get() |> take(1), currentAutodownloadSettings())
+        |> mapToSignal { initialValue, currentValue -> Signal<Void, NoError> in
+            let initialConnection = initialValue.connectionSettings(for: connectionType.automaticDownloadNetworkType)
+            let currentConnection = currentValue.connectionSettings(for: connectionType.automaticDownloadNetworkType)
+            if currentConnection != initialConnection, let categories = currentConnection.custom, currentConnection.preset == .custom {
+                let preset: SavedAutodownloadPreset
+                switch connectionType {
+                    case .cellular:
+                        preset = .medium
+                    case .wifi:
+                        preset = .high
+                }
+                let settings = AutodownloadPresetSettings(disabled: false, photoSizeMax: categories.photo.sizeLimit, videoSizeMax: categories.video.sizeLimit, fileSizeMax: categories.file.sizeLimit, preloadLargeVideo: categories.video.predownload, lessDataForPhoneCalls: false, videoUploadMaxbitrate: 0)
+                return saveAutodownloadSettings(account: context.account, preset: preset, settings: settings)
+            }
+            return .complete()
+        }).start()
+    }
+    return controller
+}
+

submodules/SettingsUI/Sources/Data and Storage/AutodownloadSizeLimitItem.swift

@@ -0,0 +1,308 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import TelegramCore
+import TelegramPresentationData
+import LegacyComponents
+import ItemListUI
+import PresentationDataUtils
+
+private let autodownloadSizeValues: [(CGFloat, Int64)] = [
+    (0.000, 512 * 1024),
+    (0.257, 1024 * 1024),
+    (0.520, 10 * 1024 * 1024),
+    (0.763, 100 * 1024 * 1024),
+    (1.000, 1536 * 1024 * 1024)
+]
+
+private func sliderValue(for size: Int64) -> CGFloat {
+    for i in 1 ..< autodownloadSizeValues.count {
+        let (previousValue, previousValueSize) = autodownloadSizeValues[i - 1]
+        let (value, valueSize) = autodownloadSizeValues[i]
+        if valueSize > size {
+            return previousValue + CGFloat(size - previousValueSize) / CGFloat(valueSize - previousValueSize) * (value - previousValue)
+        } else if previousValueSize == size {
+            return previousValue
+        } else if valueSize == size || i == autodownloadSizeValues.count - 1 {
+            return value
+        }
+    }
+    return 0.0
+}
+
+private func sizeValue(for sliderValue: CGFloat) -> Int64 {
+    for i in 1 ..< autodownloadSizeValues.count {
+        let (previousValue, previousValueSize) = autodownloadSizeValues[i - 1]
+        let (value, valueSize) = autodownloadSizeValues[i]
+        if value > sliderValue {
+            let delta = (sliderValue - previousValue) / (value - previousValue) * CGFloat(valueSize - previousValueSize)
+            return previousValueSize + Int64(delta)
+        } else if previousValue == sliderValue {
+            return previousValueSize
+        } else if value == sliderValue || i == autodownloadSizeValues.count - 1 {
+            return valueSize
+        }
+    }
+    return 0
+}
+
+final class AutodownloadSizeLimitItem: ListViewItem, ItemListItem {
+    let theme: PresentationTheme
+    let strings: PresentationStrings
+    let systemStyle: ItemListSystemStyle
+    let decimalSeparator: String
+    let text: String
+    let value: Int64
+    let range: Range<Int64>?
+    let sectionId: ItemListSectionId
+    let updated: (Int64) -> Void
+    
+    init(theme: PresentationTheme, strings: PresentationStrings, systemStyle: ItemListSystemStyle = .legacy, decimalSeparator: String, text: String, value: Int64, range: Range<Int64>?, sectionId: ItemListSectionId, updated: @escaping (Int64) -> Void) {
+        self.theme = theme
+        self.strings = strings
+        self.systemStyle = systemStyle
+        self.decimalSeparator = decimalSeparator
+        self.text = text
+        self.value = value
+        self.range = range
+        self.sectionId = sectionId
+        self.updated = updated
+    }
+    
+    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 = AutodownloadSizeLimitItemNode()
+            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 {
+            if let nodeValue = node() as? AutodownloadSizeLimitItemNode {
+                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 final class AutodownloadSizeLimitItemNode: ListViewItemNode {
+    private let backgroundNode: ASDisplayNode
+    private let topStripeNode: ASDisplayNode
+    private let bottomStripeNode: ASDisplayNode
+    private let maskNode: ASImageNode
+    
+    private let minTextNode: TextNode
+    private let maxTextNode: TextNode
+    private let textNode: TextNode
+    private var sliderView: TGPhotoEditorSliderView?
+    
+    private var item: AutodownloadSizeLimitItem?
+    private var layoutParams: ListViewItemLayoutParams?
+    
+    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.textNode = TextNode()
+        self.textNode.isUserInteractionEnabled = false
+        self.textNode.displaysAsynchronously = false
+        
+        self.minTextNode = TextNode()
+        self.minTextNode.isUserInteractionEnabled = false
+        self.minTextNode.displaysAsynchronously = false
+        
+        self.maxTextNode = TextNode()
+        self.maxTextNode.isUserInteractionEnabled = false
+        self.maxTextNode.displaysAsynchronously = false
+        
+        super.init(layerBacked: false, dynamicBounce: false)
+        
+        self.addSubnode(self.textNode)
+        self.addSubnode(self.minTextNode)
+        self.addSubnode(self.maxTextNode)
+    }
+    
+    override func didLoad() {
+        super.didLoad()
+        
+        let sliderView = TGPhotoEditorSliderView()
+        sliderView.enablePanHandling = true
+        sliderView.trackCornerRadius = 2.0
+        sliderView.lineSize = 4.0
+        sliderView.dotSize = 5.0
+        sliderView.minimumValue = 0.0
+        sliderView.maximumValue = 1.0
+        sliderView.startValue = 0.0
+        sliderView.displayEdges = true
+        sliderView.disablesInteractiveTransitionGestureRecognizer = true
+        if let item = self.item, let params = self.layoutParams {
+            sliderView.value = sliderValue(for: item.value)
+            sliderView.backgroundColor = item.theme.list.itemBlocksBackgroundColor
+            sliderView.backColor = item.theme.list.itemSwitchColors.frameColor
+            sliderView.startColor = item.theme.list.itemSwitchColors.frameColor
+            sliderView.trackColor = item.theme.list.itemAccentColor
+            sliderView.knobImage = PresentationResourcesItemList.knobImage(item.theme)
+            
+            sliderView.frame = CGRect(origin: CGPoint(x: params.leftInset + 15.0, y: 37.0), size: CGSize(width: params.width - params.leftInset - params.rightInset - 15.0 * 2.0, height: 44.0))
+            sliderView.hitTestEdgeInsets = UIEdgeInsets(top: -sliderView.frame.minX, left: 0.0, bottom: 0.0, right: -sliderView.frame.minX)
+        }
+        self.view.addSubview(sliderView)
+        sliderView.addTarget(self, action: #selector(self.sliderValueChanged), for: .valueChanged)
+        self.sliderView = sliderView
+    }
+    
+    func asyncLayout() -> (_ item: AutodownloadSizeLimitItem, _ params: ListViewItemLayoutParams, _ neighbors: ItemListNeighbors) -> (ListViewItemNodeLayout, () -> Void) {
+        let currentItem = self.item
+        let makeTextLayout = TextNode.asyncLayout(self.textNode)
+        let makeMinTextLayout = TextNode.asyncLayout(self.minTextNode)
+        let makeMaxTextLayout = TextNode.asyncLayout(self.maxTextNode)
+        
+        return { item, params, neighbors in
+            var themeUpdated = false
+            if currentItem?.theme !== item.theme {
+                themeUpdated = true
+            }
+            
+            let contentSize: CGSize
+            let insets: UIEdgeInsets
+            let separatorHeight = UIScreenPixel
+            let separatorRightInset: CGFloat = item.systemStyle == .glass ? 16.0 : 0.0
+            
+            let (textLayout, textApply) = makeTextLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: item.text, font: Font.regular(17.0), textColor: item.theme.list.itemPrimaryTextColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width, height: CGFloat.greatestFiniteMagnitude), alignment: .center, lineSpacing: 0.0, cutout: nil, insets: UIEdgeInsets()))
+            
+            let formatting = DataSizeStringFormatting(strings: item.strings, decimalSeparator: item.decimalSeparator)
+            
+            let range = item.range ?? (512 * 1024 ..< 1536 * 1024 * 1024)
+            
+            let (minTextLayout, minTextApply) = makeMinTextLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: dataSizeString(range.lowerBound, formatting: formatting), font: Font.regular(13.0), textColor: item.theme.list.itemSecondaryTextColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width, height: CGFloat.greatestFiniteMagnitude), alignment: .center, lineSpacing: 0.0, cutout: nil, insets: UIEdgeInsets()))
+            
+            let (maxTextLayout, maxTextApply) = makeMaxTextLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: dataSizeString(range.upperBound, formatting: formatting), font: Font.regular(13.0), textColor: item.theme.list.itemSecondaryTextColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width, height: CGFloat.greatestFiniteMagnitude), alignment: .center, lineSpacing: 0.0, cutout: nil, insets: UIEdgeInsets()))
+            
+            contentSize = CGSize(width: params.width, height: 88.0)
+            insets = itemListNeighborsGroupedInsets(neighbors, params)
+            
+            let layout = ListViewItemNodeLayout(contentSize: contentSize, insets: insets)
+            let layoutSize = layout.size
+            
+            return (layout, { [weak self] in
+                if let strongSelf = self {
+                    strongSelf.item = item
+                    strongSelf.layoutParams = params
+                    
+                    strongSelf.backgroundNode.backgroundColor = item.theme.list.itemBlocksBackgroundColor
+                    strongSelf.topStripeNode.backgroundColor = item.theme.list.itemBlocksSeparatorColor
+                    strongSelf.bottomStripeNode.backgroundColor = item.theme.list.itemBlocksSeparatorColor
+                    
+                    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.insertSubnode(strongSelf.maskNode, at: 3)
+                    }
+                    
+                    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 = 0.0
+                            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.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.maskNode.frame = strongSelf.backgroundNode.frame.insetBy(dx: params.leftInset, dy: 0.0)
+                    strongSelf.topStripeNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: layoutSize.width, height: separatorHeight))
+                    strongSelf.bottomStripeNode.frame = CGRect(origin: CGPoint(x: bottomStripeInset, y: contentSize.height + bottomStripeOffset), size: CGSize(width: layoutSize.width - bottomStripeInset - separatorRightInset, height: separatorHeight))
+                    
+                    let _ = textApply()
+                    strongSelf.textNode.frame = CGRect(origin: CGPoint(x: floor((params.width - textLayout.size.width) / 2.0), y: 12.0), size: textLayout.size)
+                    
+                    let _ = minTextApply()
+                    strongSelf.minTextNode.frame = CGRect(origin: CGPoint(x: params.leftInset + 16.0, y: 16.0), size: minTextLayout.size)
+                    
+                    let _ = maxTextApply()
+                    strongSelf.maxTextNode.frame = CGRect(origin: CGPoint(x: params.width - params.rightInset - 16.0 - maxTextLayout.size.width, y: 16.0), size: maxTextLayout.size)
+                    
+                    if let sliderView = strongSelf.sliderView {
+                        if themeUpdated {
+                            sliderView.backgroundColor = item.theme.list.itemBlocksBackgroundColor
+                            sliderView.backColor = item.theme.list.itemSwitchColors.frameColor
+                            sliderView.trackColor = item.theme.list.itemAccentColor
+                            sliderView.knobImage = PresentationResourcesItemList.knobImage(item.theme)
+                        }
+                        
+                        sliderView.frame = CGRect(origin: CGPoint(x: params.leftInset + 15.0, y: 37.0), size: CGSize(width: params.width - params.leftInset - params.rightInset - 15.0 * 2.0, height: 44.0))
+                        sliderView.hitTestEdgeInsets = UIEdgeInsets(top: -sliderView.frame.minX, left: 0.0, bottom: 0.0, right: -sliderView.frame.minX)
+                    }
+                }
+            })
+        }
+    }
+    
+    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 func sliderValueChanged() {
+        guard let sliderView = self.sliderView else {
+            return
+        }
+        let value = sizeValue(for: sliderView.value)
+        self.item?.updated(value)
+    }
+}

submodules/SettingsUI/Sources/Data and Storage/CalculatingCacheSizeItem.swift

@@ -0,0 +1,235 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import TelegramPresentationData
+import ItemListUI
+import PresentationDataUtils
+import ActivityIndicator
+
+final class CalculatingCacheSizeItem: ListViewItem, ItemListItem {
+    let theme: PresentationTheme
+    let title: String
+    let sectionId: ItemListSectionId
+    let style: ItemListStyle
+    
+    init(theme: PresentationTheme, title: String, sectionId: ItemListSectionId, style: ItemListStyle) {
+        self.theme = theme
+        self.title = title
+        self.sectionId = sectionId
+        self.style = style
+    }
+    
+    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 = CalculatingCacheSizeItemNode()
+            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 {
+            if let nodeValue = node() as? CalculatingCacheSizeItemNode {
+                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(14.0)
+
+private final class CalculatingCacheSizeItemNode: ListViewItemNode {
+    private let backgroundNode: ASDisplayNode
+    private let topStripeNode: ASDisplayNode
+    private let bottomStripeNode: ASDisplayNode
+    private let maskNode: ASImageNode
+    
+    private var activityIndicator: ActivityIndicator?
+    private let titleNode: TextNode
+    
+    private var item: CalculatingCacheSizeItem?
+    
+    var tag: Any? {
+        return self.item?.tag
+    }
+    
+    init() {
+        self.backgroundNode = ASDisplayNode()
+        self.backgroundNode.isLayerBacked = true
+        self.backgroundNode.backgroundColor = .white
+        
+        self.topStripeNode = ASDisplayNode()
+        self.topStripeNode.isLayerBacked = true
+        
+        self.bottomStripeNode = ASDisplayNode()
+        self.bottomStripeNode.isLayerBacked = true
+        
+        self.maskNode = ASImageNode()
+        
+        self.titleNode = TextNode()
+        self.titleNode.isUserInteractionEnabled = false
+        self.titleNode.contentMode = .left
+        self.titleNode.contentsScale = UIScreen.main.scale
+        
+        super.init(layerBacked: false, dynamicBounce: false)
+        
+        self.addSubnode(self.titleNode)
+    }
+    
+    func asyncLayout() -> (_ item: CalculatingCacheSizeItem, _ params: ListViewItemLayoutParams, _ neighbors: ItemListNeighbors) -> (ListViewItemNodeLayout, () -> Void) {
+        let makeTitleLayout = TextNode.asyncLayout(self.titleNode)
+        
+        let currentItem = self.item
+        
+        return { item, params, neighbors in
+            var updatedTheme: PresentationTheme?
+            
+            if currentItem?.theme !== item.theme {
+                updatedTheme = item.theme
+            }
+            
+            let (titleLayout, titleApply) = makeTitleLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: item.title, font: titleFont, textColor: item.theme.list.itemSecondaryTextColor), backgroundColor: nil, maximumNumberOfLines: 0, truncationType: .end, constrainedSize: CGSize(width: params.width - params.leftInset - params.rightInset - 20.0, height: CGFloat.greatestFiniteMagnitude), alignment: .center, cutout: nil, insets: UIEdgeInsets()))
+            
+            let contentSize: CGSize
+            let insets: UIEdgeInsets
+            let separatorHeight = UIScreenPixel
+            
+            let itemBackgroundColor: UIColor
+            let itemSeparatorColor: UIColor
+            switch item.style {
+                case .plain:
+                    itemBackgroundColor = item.theme.list.plainBackgroundColor
+                    itemSeparatorColor = item.theme.list.itemPlainSeparatorColor
+                    contentSize = CGSize(width: params.width, height: titleLayout.size.height + 22.0 + 24.0)
+                    insets = itemListNeighborsPlainInsets(neighbors)
+                case .blocks:
+                    itemBackgroundColor = item.theme.list.itemBlocksBackgroundColor
+                    itemSeparatorColor = item.theme.list.itemBlocksSeparatorColor
+                    contentSize = CGSize(width: params.width, height: titleLayout.size.height + 22.0 + 24.0)
+                    insets = itemListNeighborsGroupedInsets(neighbors, params)
+            }
+            
+            let layout = ListViewItemNodeLayout(contentSize: contentSize, insets: insets)
+            
+            return (layout, { [weak self] in
+                if let strongSelf = self {
+                    strongSelf.item = item
+                    
+                    let activityIndicator: ActivityIndicator
+                    if let current = strongSelf.activityIndicator {
+                        activityIndicator = current
+                    } else {
+                        activityIndicator = ActivityIndicator(type: .custom(item.theme.list.itemAccentColor, 20.0, 2.0, false), speed: ActivityIndicatorSpeed.slow)
+                        strongSelf.activityIndicator = activityIndicator
+                        strongSelf.addSubnode(activityIndicator)
+                    }
+                    
+                    if let _ = updatedTheme {
+                        strongSelf.topStripeNode.backgroundColor = itemSeparatorColor
+                        strongSelf.bottomStripeNode.backgroundColor = itemSeparatorColor
+                        strongSelf.backgroundNode.backgroundColor = itemBackgroundColor
+                        activityIndicator.type = .custom(item.theme.list.itemAccentColor, 20.0, 2.0, false)
+                    }
+                    
+                    let _ = titleApply()
+                    
+                    let leftInset: CGFloat
+                    
+                    switch item.style {
+                        case .plain:
+                            leftInset = 35.0 + params.leftInset
+                            
+                            if strongSelf.backgroundNode.supernode != nil {
+                                strongSelf.backgroundNode.removeFromSupernode()
+                            }
+                            if strongSelf.topStripeNode.supernode != nil {
+                                strongSelf.topStripeNode.removeFromSupernode()
+                            }
+                            if strongSelf.bottomStripeNode.supernode == nil {
+                                strongSelf.insertSubnode(strongSelf.bottomStripeNode, at: 0)
+                            }
+                            
+                            strongSelf.bottomStripeNode.frame = CGRect(origin: CGPoint(x: leftInset, y: contentSize.height - separatorHeight), size: CGSize(width: params.width - leftInset, height: separatorHeight))
+                        case .blocks:
+                            leftInset = 16.0 + params.leftInset
+                            
+                            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.insertSubnode(strongSelf.maskNode, at: 3)
+                            }
+                            
+                            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 = 16.0 + params.leftInset
+                                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.theme, top: hasTopCorners, bottom: hasBottomCorners) : 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.maskNode.frame = strongSelf.backgroundNode.frame.insetBy(dx: params.leftInset, dy: 0.0)
+                            strongSelf.topStripeNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: params.width, height: separatorHeight))
+                            strongSelf.bottomStripeNode.frame = CGRect(origin: CGPoint(x: bottomStripeInset, y: contentSize.height + bottomStripeOffset), size: CGSize(width: params.width - bottomStripeInset, height: separatorHeight))
+                    }
+                    
+                    strongSelf.titleNode.frame = CGRect(origin: CGPoint(x: params.leftInset + floor((params.width - params.leftInset - params.rightInset - titleLayout.size.width) / 2.0), y: 11.0 + 24.0), size: titleLayout.size)
+                    
+                    activityIndicator.frame = CGRect(origin: CGPoint(x: floor((params.width - 20.0) / 2.0), y: 8.0), size: CGSize(width: 20.0, height: 20.0))
+                }
+            })
+        }
+    }
+    
+    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)
+    }
+}

submodules/SettingsUI/Sources/Data and Storage/EnergySavingSettingsScreen.swift

@@ -0,0 +1,321 @@
+import Foundation
+import UIKit
+import Display
+import SwiftSignalKit
+import TelegramCore
+import TelegramPresentationData
+import TelegramUIPreferences
+import ItemListUI
+import PresentationDataUtils
+import AccountContext
+import UndoUI
+
+enum ItemType: CaseIterable {
+    case autoplayVideo
+    case autoplayGif
+    case loopStickers
+    case loopEmoji
+    case fullTranslucency
+    case autodownloadInBackground
+    case extendBackgroundWork
+    
+    var settingsKeyPath: WritableKeyPath<EnergyUsageSettings, Bool> {
+        switch self {
+        case .autoplayVideo:
+            return \.autoplayVideo
+        case .autoplayGif:
+            return \.autoplayGif
+        case .loopStickers:
+            return \.loopStickers
+        case .loopEmoji:
+            return \.loopEmoji
+        case .fullTranslucency:
+            return \.fullTranslucency
+        case .extendBackgroundWork:
+            return \.extendBackgroundWork
+        case .autodownloadInBackground:
+            return \.autodownloadInBackground
+        }
+    }
+    
+    func title(strings: PresentationStrings) -> (String, String, String) {
+        switch self {
+        case .autoplayVideo:
+            return (
+                "Settings/Power/PowerIconVideo",
+                strings.PowerSavingScreen_OptionAutoplayVideoTitle,
+                strings.PowerSavingScreen_OptionAutoplayVideoText
+            )
+        case .autoplayGif:
+            return (
+                "Settings/Power/PowerIconGif",
+                strings.PowerSavingScreen_OptionAutoplayGifTitle,
+                strings.PowerSavingScreen_OptionAutoplayGifText
+            )
+        case .loopStickers:
+            return (
+                "Settings/Power/PowerIconStickers",
+                strings.PowerSavingScreen_OptionAutoplayStickersTitle,
+                strings.PowerSavingScreen_OptionAutoplayStickersText
+            )
+        case .loopEmoji:
+            return (
+                "Settings/Power/PowerIconEmoji",
+                strings.PowerSavingScreen_OptionAutoplayEmojiTitle,
+                strings.PowerSavingScreen_OptionAutoplayEmojiText
+            )
+        case .fullTranslucency:
+            return (
+                "Settings/Power/PowerIconEffects",
+                strings.PowerSavingScreen_OptionAutoplayEffectsTitle,
+                strings.PowerSavingScreen_OptionAutoplayEffectsText
+            )
+        case .extendBackgroundWork:
+            return (
+                "Settings/Power/PowerIconBackgroundTime",
+                strings.PowerSavingScreen_OptionBackgroundTitle,
+                strings.PowerSavingScreen_OptionBackgroundText
+            )
+        case .autodownloadInBackground:
+            return (
+                "Settings/Power/PowerIconMedia",
+                strings.PowerSavingScreen_OptionPreloadTitle,
+                strings.PowerSavingScreen_OptionPreloadText
+            )
+        }
+    }
+}
+
+private final class EnergeSavingSettingsScreenArguments {
+    let updateThreshold: (Int32) -> Void
+    let toggleItem: (ItemType) -> Void
+    let displayDisabledTooltip: () -> Void
+    
+    init(updateThreshold: @escaping (Int32) -> Void, toggleItem: @escaping (ItemType) -> Void, displayDisabledTooltip: @escaping () -> Void) {
+        self.updateThreshold = updateThreshold
+        self.toggleItem = toggleItem
+        self.displayDisabledTooltip = displayDisabledTooltip
+    }
+}
+
+private enum EnergeSavingSettingsScreenSection: Int32 {
+    case all
+    case items
+}
+
+private enum EnergeSavingSettingsScreenEntry: ItemListNodeEntry {
+    enum StableId: Hashable {
+        case allHeader
+        case all
+        case allFooter
+        case itemsHeader
+        case item(ItemType)
+    }
+    
+    case allHeader(Bool?)
+    case all(Int32)
+    case allFooter(String)
+    case item(index: Int, type: ItemType, value: Bool, enabled: Bool)
+    case itemsHeader
+    
+    var section: ItemListSectionId {
+        switch self {
+        case .allHeader, .all, .allFooter:
+            return EnergeSavingSettingsScreenSection.all.rawValue
+        case .item, .itemsHeader:
+            return EnergeSavingSettingsScreenSection.items.rawValue
+        }
+    }
+    
+    var sortIndex: Int {
+        switch self {
+        case .allHeader:
+            return -4
+        case .all:
+            return -3
+        case .allFooter:
+            return -2
+        case .itemsHeader:
+            return -1
+        case let .item(index, _, _, _):
+            return index
+        }
+    }
+    
+    var stableId: StableId {
+        switch self {
+        case .allHeader:
+            return .allHeader
+        case .all:
+            return .all
+        case .allFooter:
+            return .allFooter
+        case .itemsHeader:
+            return .itemsHeader
+        case let .item(_, type, _, _):
+            return .item(type)
+        }
+    }
+    
+    static func <(lhs: EnergeSavingSettingsScreenEntry, rhs: EnergeSavingSettingsScreenEntry) -> Bool {
+        return lhs.sortIndex < rhs.sortIndex
+    }
+    
+    func item(presentationData: ItemListPresentationData, arguments: Any) -> ListViewItem {
+        let arguments = arguments as! EnergeSavingSettingsScreenArguments
+        switch self {
+        case let .allHeader(value):
+            let text: String
+            if let value {
+                if value {
+                    text = presentationData.strings.PowerSavingScreen_ToggleHeaderOn
+                } else {
+                    text = presentationData.strings.PowerSavingScreen_ToggleHeaderOff
+                }
+            } else {
+                text = presentationData.strings.PowerSavingScreen_ToggleHeaderEmpty
+            }
+            return ItemListSectionHeaderItem(presentationData: presentationData, text: text, sectionId: self.section)
+        case let .all(value):
+            return EnergyUsageBatteryLevelItem(
+                systemStyle: .glass,
+                theme: presentationData.theme,
+                strings: presentationData.strings,
+                value: value,
+                sectionId: self.section,
+                updated: { value in
+                    arguments.updateThreshold(value)
+                }
+            )
+        case let .allFooter(text):
+            return ItemListTextItem(presentationData: presentationData, text: .plain(text), sectionId: self.section)
+        case .itemsHeader:
+            return ItemListSectionHeaderItem(presentationData: presentationData, text: presentationData.strings.PowerSavingScreen_OptionsHeader, sectionId: self.section)
+        case let .item(_, type, value, enabled):
+            let (iconName, title, text) = type.title(strings: presentationData.strings)
+            return ItemListSwitchItem(presentationData: presentationData, systemStyle: .glass, icon: UIImage(bundleImageName: iconName)?.precomposed(), title: title, text: text, value: value, enableInteractiveChanges: true, enabled: enabled, sectionId: self.section, style: .blocks, updated: { value in
+                arguments.toggleItem(type)
+            }, activatedWhileDisabled: {
+                arguments.displayDisabledTooltip()
+            })
+        }
+    }
+}
+
+private func energeSavingSettingsScreenEntries(
+    presentationData: PresentationData,
+    settings: MediaAutoDownloadSettings
+) -> [EnergeSavingSettingsScreenEntry] {
+    var entries: [EnergeSavingSettingsScreenEntry] = []
+    
+    let isOn = automaticEnergyUsageShouldBeOnNow(settings: settings)
+    
+    let allIsOn: Bool?
+    if settings.energyUsageSettings.activationThreshold <= 4 || settings.energyUsageSettings.activationThreshold >= 96 {
+        allIsOn = nil
+    } else {
+        allIsOn = isOn
+    }
+    entries.append(.allHeader(allIsOn))
+    entries.append(.all(settings.energyUsageSettings.activationThreshold))
+    
+    let allText: String
+    if settings.energyUsageSettings.activationThreshold <= 4 {
+        allText = presentationData.strings.PowerSaving_AllDescriptionNever
+    } else if settings.energyUsageSettings.activationThreshold >= 96 {
+        allText = presentationData.strings.PowerSaving_AllDescriptionAlways
+    } else {
+        allText = presentationData.strings.PowerSaving_AllDescriptionLimit("\(settings.energyUsageSettings.activationThreshold)").string
+    }
+    entries.append(.allFooter(allText))
+    
+    let itemsEnabled: Bool
+    if settings.energyUsageSettings.activationThreshold <= 4 {
+        itemsEnabled = true
+    } else if settings.energyUsageSettings.activationThreshold >= 96 {
+        itemsEnabled = false
+    } else if isOn {
+        itemsEnabled = false
+    } else {
+        itemsEnabled = true
+    }
+    
+    entries.append(.itemsHeader)
+    for type in ItemType.allCases {
+        entries.append(.item(index: entries.count, type: type, value: settings.energyUsageSettings[keyPath: type.settingsKeyPath] && itemsEnabled, enabled: itemsEnabled))
+    }
+    
+    return entries
+}
+
+public func energySavingSettingsScreen(context: AccountContext) -> ViewController {
+    var pushControllerImpl: ((ViewController) -> Void)?
+    let _ = pushControllerImpl
+    
+    var displayTooltipImpl: ((UndoOverlayContent) -> Void)?
+    
+    let arguments = EnergeSavingSettingsScreenArguments(
+        updateThreshold: { value in
+            let _ = updateMediaDownloadSettingsInteractively(accountManager: context.sharedContext.accountManager, { settings in
+                var settings = settings
+                settings.energyUsageSettings.activationThreshold = max(4, min(96, value))
+                return settings
+            }).start()
+        },
+        toggleItem: { type in
+            let _ = updateMediaDownloadSettingsInteractively(accountManager: context.sharedContext.accountManager, { settings in
+                var settings = settings
+                settings.energyUsageSettings[keyPath: type.settingsKeyPath] = !settings.energyUsageSettings[keyPath: type.settingsKeyPath]
+                return settings
+            }).start()
+        },
+        displayDisabledTooltip: {
+            let text: String
+            if context.sharedContext.currentAutomaticMediaDownloadSettings.energyUsageSettings.activationThreshold >= 96 {
+                text = (context.sharedContext.currentPresentationData.with { $0 }).strings.PowerSavingScreen_OptionChangeAlertAlways
+            } else {
+                text = (context.sharedContext.currentPresentationData.with { $0 }).strings.PowerSavingScreen_OptionChangeAlertConditional
+            }
+            displayTooltipImpl?(.universal(animation: "lowbattery_30", scale: 1.0, colors: [:], title: nil, text: text, customUndoText: nil, timeout: 5.0))
+        }
+    )
+    
+    let signal = combineLatest(
+        context.sharedContext.presentationData,
+        context.sharedContext.accountManager.sharedData(keys: [ApplicationSpecificSharedDataKeys.automaticMediaDownloadSettings]))
+        |> deliverOnMainQueue
+        |> map { presentationData, sharedData -> (ItemListControllerState, (ItemListNodeState, Any)) in
+            var automaticMediaDownloadSettings: MediaAutoDownloadSettings
+            if let value = sharedData.entries[ApplicationSpecificSharedDataKeys.automaticMediaDownloadSettings]?.get(MediaAutoDownloadSettings.self) {
+                automaticMediaDownloadSettings = value
+            } else {
+                automaticMediaDownloadSettings = MediaAutoDownloadSettings.defaultSettings
+            }
+            
+            let controllerState = ItemListControllerState(
+                presentationData: ItemListPresentationData(presentationData),
+                title: .text(presentationData.strings.PowerSavingScreen_Title),
+                leftNavigationButton: nil,
+                rightNavigationButton: nil,
+                backNavigationButton: ItemListBackButton(title: presentationData.strings.Common_Back),
+                animateChanges: false
+            )
+            let listState = ItemListNodeState(presentationData: ItemListPresentationData(presentationData), entries: energeSavingSettingsScreenEntries(presentationData: presentationData, settings: automaticMediaDownloadSettings), style: .blocks, emptyStateItem: nil, animateChanges: true)
+            
+            return (controllerState, (listState, arguments))
+    }
+    
+    let controller = ItemListController(context: context, state: signal)
+    pushControllerImpl = { [weak controller] c in
+        if let controller = controller {
+            (controller.navigationController as? NavigationController)?.pushViewController(c)
+        }
+    }
+    displayTooltipImpl = { [weak controller] c in
+        if let controller = controller {
+            let presentationData = context.sharedContext.currentPresentationData.with({ $0 })
+            controller.present(UndoOverlayController(presentationData: presentationData, content: c, elevatedLayout: false, action: { _ in return false }), in: .current)
+        }
+    }
+    return controller
+}

submodules/SettingsUI/Sources/Data and Storage/EnergyUsageBatteryLevelItem.swift

@@ -0,0 +1,320 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import TelegramCore
+import TelegramPresentationData
+import ItemListUI
+import PresentationDataUtils
+import AppBundle
+import ComponentFlow
+import SliderComponent
+
+class EnergyUsageBatteryLevelItem: ListViewItem, ItemListItem {
+    let systemStyle: ItemListSystemStyle
+    let theme: PresentationTheme
+    let strings: PresentationStrings
+    let value: Int32
+    let sectionId: ItemListSectionId
+    let updated: (Int32) -> Void
+    
+    init(systemStyle: ItemListSystemStyle = .legacy, theme: PresentationTheme, strings: PresentationStrings, value: Int32, sectionId: ItemListSectionId, updated: @escaping (Int32) -> Void) {
+        self.systemStyle = systemStyle
+        self.theme = theme
+        self.strings = strings
+        self.value = value
+        self.sectionId = sectionId
+        self.updated = updated
+    }
+    
+    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 = EnergyUsageBatteryLevelItemNode()
+            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 {
+            if let nodeValue = node() as? EnergyUsageBatteryLevelItemNode {
+                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 func rescaleBatteryValueToSlider(_ value: CGFloat) -> CGFloat {
+    var result = (value - 0.04) / (0.96 - 0.04)
+    result = max(0.0, min(1.0, result))
+    return result
+}
+
+private func rescaleSliderToBatteryValue(_ value: CGFloat) -> CGFloat {
+    return 0.04 + (0.96 - 0.04) * value
+}
+
+class EnergyUsageBatteryLevelItemNode: ListViewItemNode {
+    private let backgroundNode: ASDisplayNode
+    private let topStripeNode: ASDisplayNode
+    private let bottomStripeNode: ASDisplayNode
+    private let maskNode: ASImageNode
+    
+    private let leftTextNode: ImmediateTextNode
+    private let rightTextNode: ImmediateTextNode
+    private let centerTextNode: ImmediateTextNode
+    private let centerMeasureTextNode: ImmediateTextNode
+    private let slider = ComponentView<Empty>()
+    
+    private let batteryImage: UIImage?
+    private let batteryBackgroundNode: ASImageNode
+    private let batteryForegroundNode: ASImageNode
+    
+    private var item: EnergyUsageBatteryLevelItem?
+    private var layoutParams: ListViewItemLayoutParams?
+    
+    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.leftTextNode = ImmediateTextNode()
+        self.rightTextNode = ImmediateTextNode()
+        self.centerTextNode = ImmediateTextNode()
+        self.centerMeasureTextNode = ImmediateTextNode()
+        
+        self.batteryImage = UIImage(bundleImageName: "Settings/UsageBatteryFrame")
+        self.batteryBackgroundNode = ASImageNode()
+        self.batteryForegroundNode = ASImageNode()
+        
+        super.init(layerBacked: false, dynamicBounce: false)
+        
+        self.addSubnode(self.leftTextNode)
+        self.addSubnode(self.rightTextNode)
+        self.addSubnode(self.centerTextNode)
+        self.addSubnode(self.batteryBackgroundNode)
+        self.addSubnode(self.batteryForegroundNode)
+    }
+        
+    func asyncLayout() -> (_ item: EnergyUsageBatteryLevelItem, _ params: ListViewItemLayoutParams, _ neighbors: ItemListNeighbors) -> (ListViewItemNodeLayout, () -> Void) {
+        return { item, params, neighbors in
+            let contentSize: CGSize
+            let insets: UIEdgeInsets
+            let separatorHeight = UIScreenPixel
+            let separatorRightInset: CGFloat = item.systemStyle == .glass ? 16.0 : 0.0
+            
+            var verticalInset: CGFloat = 0.0
+            if case .glass = item.systemStyle {
+                verticalInset = 4.0
+            }
+            
+            contentSize = CGSize(width: params.width, height: 88.0 + verticalInset * 2.0)
+            insets = itemListNeighborsGroupedInsets(neighbors, params)
+            
+            let layout = ListViewItemNodeLayout(contentSize: contentSize, insets: insets)
+            let layoutSize = layout.size
+            
+            return (layout, { [weak self] in
+                if let strongSelf = self {
+                    strongSelf.item = item
+                    strongSelf.layoutParams = params
+                    
+                    strongSelf.backgroundNode.backgroundColor = item.theme.list.itemBlocksBackgroundColor
+                    strongSelf.topStripeNode.backgroundColor = item.theme.list.itemBlocksSeparatorColor
+                    strongSelf.bottomStripeNode.backgroundColor = item.theme.list.itemBlocksSeparatorColor
+                    
+                    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.insertSubnode(strongSelf.maskNode, at: 3)
+                    }
+                    
+                    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 = params.leftInset + 16.0
+                            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.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.maskNode.frame = strongSelf.backgroundNode.frame.insetBy(dx: params.leftInset, dy: 0.0)
+                    strongSelf.topStripeNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: layoutSize.width, height: separatorHeight))
+                    strongSelf.bottomStripeNode.frame = CGRect(origin: CGPoint(x: bottomStripeInset, y: contentSize.height + bottomStripeOffset), size: CGSize(width: layoutSize.width - bottomStripeInset - params.rightInset - separatorRightInset, height: separatorHeight))
+                    
+                    strongSelf.leftTextNode.attributedText = NSAttributedString(string: item.strings.PowerSaving_BatteryLevelLimit_Off, font: Font.regular(13.0), textColor: item.theme.list.itemSecondaryTextColor)
+                    strongSelf.rightTextNode.attributedText = NSAttributedString(string: item.strings.PowerSaving_BatteryLevelLimit_On, font: Font.regular(13.0), textColor: item.theme.list.itemSecondaryTextColor)
+                    
+                    let centralText: String
+                    let centralMeasureText: String
+                    if item.value <= 4 {
+                        centralText = item.strings.PowerSaving_BatteryLevelLimit_AlwaysOff
+                        centralMeasureText = centralText
+                        strongSelf.batteryBackgroundNode.isHidden = true
+                    } else if item.value >= 96 {
+                        centralText = item.strings.PowerSaving_BatteryLevelLimit_AlwaysOn
+                        centralMeasureText = centralText
+                        strongSelf.batteryBackgroundNode.isHidden = true
+                    } else {
+                        centralText = item.strings.PowerSaving_BatteryLevelLimit_WhenBelow("\(item.value)").string
+                        centralMeasureText = item.strings.PowerSaving_BatteryLevelLimit_WhenBelow("99").string
+                        strongSelf.batteryBackgroundNode.isHidden = false
+                    }
+                    strongSelf.batteryForegroundNode.isHidden = strongSelf.batteryBackgroundNode.isHidden
+                    strongSelf.centerTextNode.attributedText = NSAttributedString(string: centralText, font: Font.regular(16.0), textColor: item.theme.list.itemPrimaryTextColor)
+                    strongSelf.centerMeasureTextNode.attributedText = NSAttributedString(string: centralMeasureText, font: Font.regular(16.0), textColor: item.theme.list.itemPrimaryTextColor)
+                    
+                    let leftTextSize = strongSelf.leftTextNode.updateLayout(CGSize(width: 100.0, height: 100.0))
+                    let rightTextSize = strongSelf.rightTextNode.updateLayout(CGSize(width: 100.0, height: 100.0))
+                    let centerTextSize = strongSelf.centerTextNode.updateLayout(CGSize(width: 200.0, height: 100.0))
+                    let centerMeasureTextSize = strongSelf.centerMeasureTextNode.updateLayout(CGSize(width: 200.0, height: 100.0))
+                    
+                    let sideInset: CGFloat = 18.0
+                    
+                    strongSelf.leftTextNode.frame = CGRect(origin: CGPoint(x: params.leftInset + sideInset, y: 15.0 + verticalInset), size: leftTextSize)
+                    strongSelf.rightTextNode.frame = CGRect(origin: CGPoint(x: params.width - params.leftInset - sideInset - rightTextSize.width, y: 15.0 + verticalInset), size: rightTextSize)
+                    
+                    var centerFrame = CGRect(origin: CGPoint(x: floor((params.width - centerMeasureTextSize.width) / 2.0), y: 11.0 + verticalInset), size: centerTextSize)
+                    if !strongSelf.batteryBackgroundNode.isHidden {
+                        centerFrame.origin.x -= 12.0
+                    }
+                    strongSelf.centerTextNode.frame = centerFrame
+                    
+                    if let frameImage = strongSelf.batteryImage {
+                        strongSelf.batteryBackgroundNode.image = generateImage(frameImage.size, rotatedContext: { size, context in
+                            UIGraphicsPushContext(context)
+                            
+                            context.clear(CGRect(origin: CGPoint(), size: size))
+                            
+                            if let image = generateTintedImage(image: frameImage, color: item.theme.list.itemPrimaryTextColor.withMultipliedAlpha(0.9)) {
+                                image.draw(in: CGRect(origin: CGPoint(), size: size))
+                                
+                                let contentRect = CGRect(origin: CGPoint(x: 3.0, y: (size.height - 9.0) * 0.5), size: CGSize(width: 20.8, height: 9.0))
+                                context.addPath(UIBezierPath(roundedRect: contentRect, cornerRadius: 2.0).cgPath)
+                                context.clip()
+                            }
+                            
+                            UIGraphicsPopContext()
+                        })
+                        strongSelf.batteryForegroundNode.image = generateImage(frameImage.size, rotatedContext: { size, context in
+                            UIGraphicsPushContext(context)
+                            
+                            context.clear(CGRect(origin: CGPoint(), size: size))
+                            
+                            let contentRect = CGRect(origin: CGPoint(x: 3.0, y: (size.height - 9.0) * 0.5), size: CGSize(width: 20.8, height: 9.0))
+                            context.addPath(UIBezierPath(roundedRect: contentRect, cornerRadius: 2.0).cgPath)
+                            context.clip()
+                            
+                            context.setFillColor(UIColor.white.cgColor)
+                            context.addPath(UIBezierPath(roundedRect: CGRect(origin: contentRect.origin, size: CGSize(width: contentRect.width * CGFloat(item.value) / 100.0, height: contentRect.height)), cornerRadius: 1.0).cgPath)
+                            context.fillPath()
+                            
+                            UIGraphicsPopContext()
+                        })
+                        
+                        let batteryColor: UIColor
+                        if item.value <= 20 {
+                            batteryColor = UIColor(rgb: 0xFF3B30)
+                        } else {
+                            batteryColor = item.theme.list.itemSwitchColors.positiveColor
+                        }
+                        
+                        if strongSelf.batteryForegroundNode.layer.layerTintColor == nil {
+                            strongSelf.batteryForegroundNode.layer.layerTintColor = batteryColor.cgColor
+                        } else {
+                            ContainedViewLayoutTransition.animated(duration: 0.2, curve: .easeInOut).updateTintColor(layer: strongSelf.batteryForegroundNode.layer, color: batteryColor)
+                        }
+                        
+                        strongSelf.batteryBackgroundNode.frame = CGRect(origin: CGPoint(x: centerFrame.minX + centerMeasureTextSize.width + 4.0, y: floor(centerFrame.midY - frameImage.size.height * 0.5)), size: frameImage.size)
+                        strongSelf.batteryForegroundNode.frame = strongSelf.batteryBackgroundNode.frame
+                    }
+                    
+                    let sliderSize = strongSelf.slider.update(
+                        transition: .immediate,
+                        component: AnyComponent(
+                            SliderComponent(
+                                content: .continuous(.init(
+                                    value: rescaleBatteryValueToSlider(CGFloat(item.value) / 100.0),
+                                    minValue: nil,
+                                    valueUpdated: { [weak self] value in
+                                        self?.item?.updated(Int32(rescaleSliderToBatteryValue(value) * 100.0))
+                                    }
+                                )),
+                                useNative: true,
+                                trackBackgroundColor: item.theme.list.itemSwitchColors.frameColor,
+                                trackForegroundColor: item.theme.list.itemAccentColor
+                            )
+                        ),
+                        environment: {},
+                        containerSize: CGSize(width: params.width - params.leftInset - params.rightInset - 15.0 * 2.0, height: 44.0)
+                    )
+                    if let sliderView = strongSelf.slider.view {
+                        if sliderView.superview == nil {
+                            strongSelf.view.addSubview(sliderView)
+                        }
+                        sliderView.frame = CGRect(origin: CGPoint(x: floorToScreenPixels((params.width - sliderSize.width) / 2.0), y: 36.0 + verticalInset), size: sliderSize)
+                    }
+                }
+            })
+        }
+    }
+    
+    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)
+    }
+}
+

submodules/SettingsUI/Sources/Data and Storage/IntentsSettingsController.swift

@@ -0,0 +1,321 @@
+import Foundation
+import UIKit
+import Display
+import SwiftSignalKit
+import Postbox
+import TelegramCore
+import TelegramPresentationData
+import TelegramUIPreferences
+import ItemListUI
+import ItemListPeerItem
+import AccountContext
+import TelegramIntents
+import AccountUtils
+
+private final class IntentsSettingsControllerArguments {
+    let context: AccountContext
+    let updateSettings: (@escaping (IntentsSettings) -> IntentsSettings) -> Void
+    let resetAll: () -> Void
+    
+    init(context: AccountContext, updateSettings: @escaping (@escaping (IntentsSettings) -> IntentsSettings) -> Void, resetAll: @escaping () -> Void) {
+        self.context = context
+        self.updateSettings = updateSettings
+        self.resetAll = resetAll
+    }
+}
+
+private enum IntentsSettingsSection: Int32 {
+    case account
+    case chats
+    case suggest
+    case reset
+}
+
+private enum IntentsSettingsControllerEntry: ItemListNodeEntry {
+    case accountHeader(PresentationTheme, String)
+    case account(PresentationTheme, EnginePeer, Bool, Int32)
+    case accountInfo(PresentationTheme, String)
+    
+    case chatsHeader(PresentationTheme, String)
+    case contacts(PresentationTheme, String, Bool)
+    case savedMessages(PresentationTheme, String, Bool)
+    case privateChats(PresentationTheme, String, Bool)
+    case groups(PresentationTheme, String, Bool)
+    case chatsInfo(PresentationTheme, String)
+    
+    case suggestHeader(PresentationTheme, String)
+    case suggestAll(PresentationTheme, String, Bool)
+    case suggestOnlyShared(PresentationTheme, String, Bool)
+    
+    case resetAll(PresentationTheme, String)
+    
+    var section: ItemListSectionId {
+        switch self {
+            case .accountHeader, .account, .accountInfo:
+                return IntentsSettingsSection.account.rawValue
+            case .chatsHeader, .contacts, .savedMessages, .privateChats, .groups, .chatsInfo:
+                   return IntentsSettingsSection.chats.rawValue
+            case .suggestHeader, .suggestAll, .suggestOnlyShared:
+                return IntentsSettingsSection.suggest.rawValue
+            case .resetAll:
+                return IntentsSettingsSection.reset.rawValue
+        }
+    }
+    
+    var stableId: Int32 {
+        switch self {
+            case .accountHeader:
+                return 0
+            case let .account(_, _, _, index):
+                return 1 + index
+            case .accountInfo:
+                return 1000
+            case .chatsHeader:
+                return 1001
+            case .contacts:
+                return 1002
+            case .savedMessages:
+                return 1003
+            case .privateChats:
+                return 1004
+            case .groups:
+                return 1005
+            case .chatsInfo:
+                return 1006
+            case .suggestHeader:
+                return 1007
+            case .suggestAll:
+                return 1008
+            case .suggestOnlyShared:
+                return 1009
+            case .resetAll:
+                return 1010
+        }
+    }
+    
+    static func ==(lhs: IntentsSettingsControllerEntry, rhs: IntentsSettingsControllerEntry) -> Bool {
+        switch lhs {
+            case let .accountHeader(lhsTheme, lhsText):
+                if case let .accountHeader(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .account(lhsTheme, lhsPeer, lhsSelected, lhsIndex):
+                if case let .account(rhsTheme, rhsPeer, rhsSelected, rhsIndex) = rhs, lhsTheme === rhsTheme, lhsPeer == rhsPeer, lhsSelected == rhsSelected, lhsIndex == rhsIndex {
+                    return true
+                } else {
+                    return false
+                }
+            case let .accountInfo(lhsTheme, lhsText):
+                if case let .accountInfo(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+           
+            case let .chatsHeader(lhsTheme, lhsText):
+                if case let .chatsHeader(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .contacts(lhsTheme, lhsText, lhsValue):
+                if case let .contacts(rhsTheme, rhsText, rhsValue) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue {
+                    return true
+                } else {
+                    return false
+                }
+            case let .savedMessages(lhsTheme, lhsText, lhsValue):
+                if case let .savedMessages(rhsTheme, rhsText, rhsValue) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue {
+                    return true
+                } else {
+                    return false
+                }
+            case let .privateChats(lhsTheme, lhsText, lhsValue):
+                if case let .privateChats(rhsTheme, rhsText, rhsValue) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue {
+                    return true
+                } else {
+                    return false
+                }
+            case let .groups(lhsTheme, lhsText, lhsValue):
+                if case let .groups(rhsTheme, rhsText, rhsValue) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue {
+                    return true
+                } else {
+                    return false
+                }
+            case let .chatsInfo(lhsTheme, lhsText):
+                if case let .chatsInfo(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .suggestHeader(lhsTheme, lhsText):
+                if case let .suggestHeader(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .suggestAll(lhsTheme, lhsText, lhsValue):
+                if case let .suggestAll(rhsTheme, rhsText, rhsValue) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue {
+                    return true
+                } else {
+                    return false
+                }
+            case let .suggestOnlyShared(lhsTheme, lhsText, lhsValue):
+                if case let .suggestOnlyShared(rhsTheme, rhsText, rhsValue) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue {
+                    return true
+                } else {
+                    return false
+                }
+            case let .resetAll(lhsTheme, lhsText):
+                if case let .resetAll(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+        }
+    }
+        
+    static func <(lhs: IntentsSettingsControllerEntry, rhs: IntentsSettingsControllerEntry) -> Bool {
+        return lhs.stableId < rhs.stableId
+    }
+    
+    func item(presentationData: ItemListPresentationData, arguments: Any) -> ListViewItem {
+        let arguments = arguments as! IntentsSettingsControllerArguments
+        switch self {
+            case let .accountHeader(_, text):
+                return ItemListSectionHeaderItem(presentationData: presentationData, text: text, sectionId: self.section)
+            case let .account(_, peer, selected, _):
+                return ItemListPeerItem(presentationData: presentationData, systemStyle: .glass, dateTimeFormat: PresentationDateTimeFormat(), nameDisplayOrder: .firstLast, context: arguments.context.sharedContext.makeTempAccountContext(account: arguments.context.account), peer: peer, height: .generic, aliasHandling: .standard, nameStyle: .plain, presence: nil, text: .none, label: .none, editing: ItemListPeerItemEditing(editable: true, editing: false, revealed: false), revealOptions: nil, switchValue: ItemListPeerItemSwitch(value: selected, style: .check), enabled: true, selectable: true, sectionId: self.section, action: {
+                    arguments.updateSettings { $0.withUpdatedAccount(peer.id) }
+                }, setPeerIdWithRevealedOptions: { _, _ in}, removePeer: { _ in })
+            case let .accountInfo(_, text):
+                return ItemListTextItem(presentationData: presentationData, text: .plain(text), sectionId: self.section)
+            case let .chatsHeader(_, text):
+                return ItemListSectionHeaderItem(presentationData: presentationData, text: text, sectionId: self.section)
+            case let .contacts(_, text, value):
+                return ItemListSwitchItem(presentationData: presentationData, systemStyle: .glass, title: text, value: value, enableInteractiveChanges: true, enabled: true, sectionId: self.section, style: .blocks, updated: { value in
+                    arguments.updateSettings { $0.withUpdatedContacts(value) }
+                })
+            case let .savedMessages(_, text, value):
+                return ItemListSwitchItem(presentationData: presentationData, systemStyle: .glass, title: text, value: value, enableInteractiveChanges: true, enabled: true, sectionId: self.section, style: .blocks, updated: { value in
+                    arguments.updateSettings { $0.withUpdatedSavedMessages(value) }
+                })
+            case let .privateChats(_, text, value):
+                return ItemListSwitchItem(presentationData: presentationData, systemStyle: .glass, title: text, value: value, enableInteractiveChanges: true, enabled: true, sectionId: self.section, style: .blocks, updated: { value in
+                    arguments.updateSettings { $0.withUpdatedPrivateChats(value) }
+                })
+            case let .groups(_, text, value):
+                return ItemListSwitchItem(presentationData: presentationData, systemStyle: .glass, title: text, value: value, enableInteractiveChanges: true, enabled: true, sectionId: self.section, style: .blocks, updated: { value in
+                    arguments.updateSettings { $0.withUpdatedGroups(value) }
+                })
+            case let .chatsInfo(_, text):
+                return ItemListTextItem(presentationData: presentationData, text: .plain(text), sectionId: self.section)
+            case let .suggestHeader(_, text):
+                return ItemListSectionHeaderItem(presentationData: presentationData, text: text, sectionId: self.section)
+            case let .suggestAll(_, text, value):
+                return ItemListCheckboxItem(presentationData: presentationData, systemStyle: .glass, title: text, style: .left, checked: value, zeroSeparatorInsets: false, sectionId: self.section, action: {
+                    arguments.updateSettings { $0.withUpdatedOnlyShared(false) }
+                })
+            case let .suggestOnlyShared(_, text, value):
+                return ItemListCheckboxItem(presentationData: presentationData, systemStyle: .glass, title: text, style: .left, checked: value, zeroSeparatorInsets: false, sectionId: self.section, action: {
+                    arguments.updateSettings { $0.withUpdatedOnlyShared(true) }
+                })
+
+            case let .resetAll(_, text):
+                return ItemListActionItem(presentationData: presentationData, systemStyle: .glass, title: text, kind: .destructive, alignment: .natural, sectionId: self.section, style: .blocks, action: {
+                    arguments.resetAll()
+                })
+        }
+    }
+}
+
+private func intentsSettingsControllerEntries(context: AccountContext, presentationData: PresentationData, settings: IntentsSettings, accounts: [(Account, EnginePeer)]) -> [IntentsSettingsControllerEntry] {
+    var entries: [IntentsSettingsControllerEntry] = []
+    
+    if accounts.count > 1 {
+        entries.append(.accountHeader(presentationData.theme, presentationData.strings.IntentsSettings_MainAccount.uppercased()))
+        var index: Int32 = 0
+        for (_, peer) in accounts {
+            entries.append(.account(presentationData.theme, peer, peer.id == settings.account, index))
+            index += 1
+        }
+        entries.append(.accountInfo(presentationData.theme, presentationData.strings.IntentsSettings_MainAccountInfo))
+    }
+    
+    entries.append(.chatsHeader(presentationData.theme, presentationData.strings.IntentsSettings_SuggestedChats.uppercased()))
+    entries.append(.contacts(presentationData.theme, presentationData.strings.IntentsSettings_SuggestedChatsContacts, settings.contacts))
+    entries.append(.savedMessages(presentationData.theme, presentationData.strings.IntentsSettings_SuggestedChatsSavedMessages, settings.savedMessages))
+    entries.append(.privateChats(presentationData.theme, presentationData.strings.IntentsSettings_SuggestedChatsPrivateChats, settings.privateChats))
+    entries.append(.groups(presentationData.theme, presentationData.strings.IntentsSettings_SuggestedChatsGroups, settings.groups))
+    
+    entries.append(.chatsInfo(presentationData.theme, presentationData.strings.IntentsSettings_SuggestedAndSpotlightChatsInfo))
+    
+    entries.append(.suggestHeader(presentationData.theme, presentationData.strings.IntentsSettings_SuggestBy.uppercased()))
+    entries.append(.suggestAll(presentationData.theme, presentationData.strings.IntentsSettings_SuggestByAll, !settings.onlyShared))
+    entries.append(.suggestOnlyShared(presentationData.theme, presentationData.strings.IntentsSettings_SuggestByShare, settings.onlyShared))
+    
+    entries.append(.resetAll(presentationData.theme, presentationData.strings.IntentsSettings_ResetAll))
+    
+    return entries
+}
+
+public func intentsSettingsController(context: AccountContext) -> ViewController {
+    var presentControllerImpl: ((ViewController) -> Void)?
+
+    let arguments = IntentsSettingsControllerArguments(context: context, updateSettings: { f in
+        let _ = updateIntentsSettingsInteractively(accountManager: context.sharedContext.accountManager, f).start(next: { previous, updated in
+            guard let previous = previous, let updated = updated else {
+                return
+            }
+            if previous.contacts && !updated.contacts {
+                deleteAllSendMessageIntents()
+            }
+            if previous.savedMessages && !updated.savedMessages {
+                deleteAllSendMessageIntents()
+            }
+            if previous.privateChats && !updated.privateChats {
+                deleteAllSendMessageIntents()
+            }
+            if previous.groups && !updated.groups {
+                deleteAllSendMessageIntents()
+            }
+            if previous.account != updated.account, let _ = previous.account {
+                deleteAllSendMessageIntents()
+            }
+        })
+    }, resetAll: {
+        let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+        let actionSheet = ActionSheetController(presentationData: presentationData)
+        actionSheet.setItemGroups([ActionSheetItemGroup(items: [
+            ActionSheetButtonItem(title: presentationData.strings.IntentsSettings_Reset, color: .destructive, action: { [weak actionSheet] in
+                actionSheet?.dismissAnimated()
+                
+                deleteAllSendMessageIntents()
+            })
+        ]), ActionSheetItemGroup(items: [
+            ActionSheetButtonItem(title: presentationData.strings.Common_Cancel, color: .accent, font: .bold, action: { [weak actionSheet] in
+                actionSheet?.dismissAnimated()
+            })
+        ])])
+        presentControllerImpl?(actionSheet)
+    })
+    
+    let signal = combineLatest(context.sharedContext.presentationData, context.sharedContext.accountManager.sharedData(keys: [ApplicationSpecificSharedDataKeys.intentsSettings]), activeAccountsAndPeers(context: context, includePrimary: true))
+    |> deliverOnMainQueue
+    |> map { presentationData, sharedData, accounts -> (ItemListControllerState, (ItemListNodeState, Any)) in
+        let settings = sharedData.entries[ApplicationSpecificSharedDataKeys.intentsSettings]?.get(IntentsSettings.self) ?? IntentsSettings.defaultSettings
+        
+        let controllerState = ItemListControllerState(presentationData: ItemListPresentationData(presentationData), title: .text(presentationData.strings.IntentsSettings_Title), leftNavigationButton: nil, rightNavigationButton: nil, backNavigationButton: ItemListBackButton(title: presentationData.strings.Common_Back))
+        let listState = ItemListNodeState(presentationData: ItemListPresentationData(presentationData), entries: intentsSettingsControllerEntries(context: context, presentationData: presentationData, settings: settings, accounts: accounts.1.map { ($0.0.account, $0.1) }), style: .blocks, animateChanges: false)
+        
+        return (controllerState, (listState, arguments))
+    }
+    
+    let controller = ItemListController(context: context, state: signal)
+    presentControllerImpl = { [weak controller] c in
+        controller?.present(c, in: .window(.root))
+    }
+    return controller
+}

submodules/SettingsUI/Sources/Data and Storage/KeepMediaDurationPickerItem.swift

@@ -0,0 +1,307 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import TelegramCore
+import TelegramUIPreferences
+import TelegramPresentationData
+import LegacyComponents
+import ItemListUI
+import PresentationDataUtils
+
+private func stringForKeepMediaTimeout(strings: PresentationStrings, timeout: Int32) -> String {
+    if timeout > 1 * 31 * 24 * 60 * 60 {
+        return strings.ClearCache_Forever
+    } else {
+        return timeIntervalString(strings: strings, value: timeout)
+    }
+}
+
+private let keepMediaTimeoutValues: [Int32] = [
+    3 * 24 * 60 * 60,
+    7 * 24 * 60 * 60,
+    1 * 31 * 24 * 60 * 60,
+    Int32.max
+]
+
+final class KeepMediaDurationPickerItem: ListViewItem, ItemListItem {
+    let theme: PresentationTheme
+    let strings: PresentationStrings
+    let value: Int32
+    let sectionId: ItemListSectionId
+    let updated: (Int32) -> Void
+    
+    init(theme: PresentationTheme, strings: PresentationStrings, value: Int32, sectionId: ItemListSectionId, updated: @escaping (Int32) -> Void) {
+        self.theme = theme
+        self.strings = strings
+        self.value = value
+        self.sectionId = sectionId
+        self.updated = updated
+    }
+    
+    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 = KeepMediaDurationPickerItemNode()
+            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 {
+            if let nodeValue = node() as? KeepMediaDurationPickerItemNode {
+                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 final class KeepMediaDurationPickerItemNode: ListViewItemNode {
+    private let backgroundNode: ASDisplayNode
+    private let topStripeNode: ASDisplayNode
+    private let bottomStripeNode: ASDisplayNode
+    private let maskNode: ASImageNode
+    
+    private let textNodes: [TextNode]
+    private var sliderView: TGPhotoEditorSliderView?
+    
+    private var item: KeepMediaDurationPickerItem?
+    private var layoutParams: ListViewItemLayoutParams?
+    
+    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()
+        
+        var textNodes: [TextNode] = []
+        for _ in 0 ..< 4 {
+            let textNode = TextNode()
+            textNode.isUserInteractionEnabled = false
+            textNode.displaysAsynchronously = false
+            textNodes.append(textNode)
+        }
+        self.textNodes = textNodes
+
+        super.init(layerBacked: false, dynamicBounce: false)
+        
+        for textNode in textNodes {
+            self.addSubnode(textNode)
+        }
+    }
+    
+    func updateSliderView() {
+        if let sliderView = self.sliderView, let item = self.item {
+            sliderView.maximumValue = 3.0
+            sliderView.positionsCount = 4
+            
+            let value = keepMediaTimeoutValues.firstIndex(where: { $0 == item.value }) ?? 0
+            sliderView.value = CGFloat(value)
+        }
+    }
+    
+    override func didLoad() {
+        super.didLoad()
+        
+        let sliderView = TGPhotoEditorSliderView()
+        sliderView.enablePanHandling = true
+        sliderView.trackCornerRadius = 2.0
+        sliderView.lineSize = 4.0
+        sliderView.dotSize = 5.0
+        sliderView.minimumValue = 0.0
+        sliderView.maximumValue = 3.0
+        sliderView.startValue = 0.0
+        sliderView.disablesInteractiveTransitionGestureRecognizer = true
+        sliderView.positionsCount = 4
+        sliderView.useLinesForPositions = true
+        if let item = self.item, let params = self.layoutParams {
+            let value = keepMediaTimeoutValues.firstIndex(where: { $0 == item.value }) ?? 0
+          
+            sliderView.value = CGFloat(value)
+            sliderView.backgroundColor = item.theme.list.itemBlocksBackgroundColor
+            sliderView.backColor = item.theme.list.itemSwitchColors.frameColor.blitOver(item.theme.list.itemBlocksBackgroundColor, alpha: 1.0)
+            sliderView.startColor = item.theme.list.itemSwitchColors.frameColor.blitOver(item.theme.list.itemBlocksBackgroundColor, alpha: 1.0)
+            sliderView.trackColor = item.theme.list.itemAccentColor.blitOver(item.theme.list.itemBlocksBackgroundColor, alpha: 1.0)
+            sliderView.knobImage = PresentationResourcesItemList.knobImage(item.theme)
+            
+            sliderView.frame = CGRect(origin: CGPoint(x: params.leftInset + 15.0, y: 37.0), size: CGSize(width: params.width - params.leftInset - params.rightInset - 15.0 * 2.0, height: 44.0))
+            sliderView.hitTestEdgeInsets = UIEdgeInsets(top: -sliderView.frame.minX, left: 0.0, bottom: 0.0, right: -sliderView.frame.minX)
+        }
+        self.view.addSubview(sliderView)
+        sliderView.addTarget(self, action: #selector(self.sliderValueChanged), for: .valueChanged)
+        self.sliderView = sliderView
+        
+        self.updateSliderView()
+    }
+    
+    func asyncLayout() -> (_ item: KeepMediaDurationPickerItem, _ params: ListViewItemLayoutParams, _ neighbors: ItemListNeighbors) -> (ListViewItemNodeLayout, () -> Void) {
+        let currentItem = self.item
+        var makeTextLayouts: [(TextNodeLayoutArguments) -> (TextNodeLayout, () -> TextNode)] = []
+        for textNode in self.textNodes {
+            makeTextLayouts.append(TextNode.asyncLayout(textNode))
+        }
+
+        return { item, params, neighbors in
+            var themeUpdated = false
+            if currentItem?.theme !== item.theme {
+                themeUpdated = true
+            }
+            
+            let contentSize: CGSize
+            let insets: UIEdgeInsets
+            let separatorHeight = UIScreenPixel
+            
+            var textLayouts: [TextNodeLayout] = []
+            var textApplies: [() -> TextNode] = []
+                                    
+            for i in 0 ..< makeTextLayouts.count {
+                let makeTextLayout = makeTextLayouts[i]
+                let (textLayout, textApply) = makeTextLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: stringForKeepMediaTimeout(strings: item.strings, timeout: keepMediaTimeoutValues[i]), font: Font.regular(13.0), textColor: item.theme.list.itemSecondaryTextColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width, height: CGFloat.greatestFiniteMagnitude), alignment: .center, lineSpacing: 0.0, cutout: nil, insets: UIEdgeInsets()))
+                textLayouts.append(textLayout)
+                textApplies.append(textApply)
+            }
+            
+            contentSize = CGSize(width: params.width, height: 88.0)
+            insets = itemListNeighborsGroupedInsets(neighbors, params)
+            
+            let layout = ListViewItemNodeLayout(contentSize: contentSize, insets: insets)
+            let layoutSize = layout.size
+            
+            return (layout, { [weak self] in
+                if let strongSelf = self {
+                    strongSelf.item = item
+                    strongSelf.layoutParams = params
+                    
+                    strongSelf.backgroundNode.backgroundColor = item.theme.list.itemBlocksBackgroundColor
+                    strongSelf.topStripeNode.backgroundColor = item.theme.list.itemBlocksSeparatorColor
+                    strongSelf.bottomStripeNode.backgroundColor = item.theme.list.itemBlocksSeparatorColor
+                    
+                    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.insertSubnode(strongSelf.maskNode, at: 3)
+                    }
+                    
+                    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 = 0.0
+                        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.theme, top: hasTopCorners, bottom: hasBottomCorners) : 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.maskNode.frame = strongSelf.backgroundNode.frame.insetBy(dx: params.leftInset, dy: 0.0)
+                    strongSelf.topStripeNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: layoutSize.width, height: separatorHeight))
+                    strongSelf.bottomStripeNode.frame = CGRect(origin: CGPoint(x: bottomStripeInset, y: contentSize.height + bottomStripeOffset), size: CGSize(width: layoutSize.width - bottomStripeInset, height: separatorHeight))
+                    
+                    for apply in textApplies {
+                        let _ = apply()
+                    }
+                    
+                    var textNodes: [(TextNode, CGSize)] = []
+                    for (node, size) in zip(strongSelf.textNodes, textLayouts.map { $0.size }) {
+                        textNodes.append((node, size))
+                    }
+                    
+                    let delta = (params.width - params.leftInset - params.rightInset - 18.0 * 2.0) / CGFloat(textNodes.count - 1)
+                    for i in 0 ..< textNodes.count {
+                        let (textNode, textSize) = textNodes[i]
+                        
+                        var position = params.leftInset + 18.0 + delta * CGFloat(i)
+                        if i == textNodes.count - 1 {
+                            position -= textSize.width
+                        } else if i > 0 {
+                            position -= textSize.width / 2.0
+                        }
+                        
+                        textNode.frame = CGRect(origin: CGPoint(x: position, y: 15.0), size: textSize)
+                    }
+                    
+                    if let sliderView = strongSelf.sliderView {
+                        if themeUpdated {
+                            sliderView.backgroundColor = item.theme.list.itemBlocksBackgroundColor
+                            sliderView.backColor = item.theme.list.itemSwitchColors.frameColor
+                            sliderView.startColor = item.theme.list.itemSwitchColors.frameColor
+                            sliderView.trackColor = item.theme.list.itemAccentColor
+                            sliderView.knobImage = PresentationResourcesItemList.knobImage(item.theme)
+                        }
+                        
+                        sliderView.frame = CGRect(origin: CGPoint(x: params.leftInset + 15.0, y: 37.0), size: CGSize(width: params.width - params.leftInset - params.rightInset - 15.0 * 2.0, height: 44.0))
+                        sliderView.hitTestEdgeInsets = UIEdgeInsets(top: -sliderView.frame.minX, left: 0.0, bottom: 0.0, right: -sliderView.frame.minX)
+                        
+                        strongSelf.updateSliderView()
+                    }
+                }
+            })
+        }
+    }
+    
+    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 sliderValueChanged() {
+        guard let sliderView = self.sliderView else {
+            return
+        }
+        
+        let position = Int(sliderView.value)
+        let value = keepMediaTimeoutValues[position]
+        self.item?.updated(value)
+    }
+}
+

submodules/SettingsUI/Sources/Data and Storage/MaximumCacheSizePickerItem.swift

@@ -0,0 +1,322 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import TelegramCore
+import TelegramUIPreferences
+import TelegramPresentationData
+import LegacyComponents
+import ItemListUI
+import PresentationDataUtils
+
+private func totalDiskSpace() -> Int64 {
+    do {
+        let systemAttributes = try FileManager.default.attributesOfFileSystem(forPath: NSHomeDirectory() as String)
+        return (systemAttributes[FileAttributeKey.systemSize] as? NSNumber)?.int64Value ?? 0
+    } catch {
+        return 0
+    }
+}
+
+private func stringForCacheSize(strings: PresentationStrings, size: Int32) -> String {
+    if size > 100 {
+        return strings.Cache_NoLimit
+    } else {
+        return dataSizeString(Int64(size) * 1024 * 1024 * 1024, formatting: DataSizeStringFormatting(strings: strings, decimalSeparator: "."))
+    }
+}
+
+private let maximumCacheSizeValues: [Int32] = {
+    let diskSpace = totalDiskSpace()
+    if diskSpace > 100 * 1024 * 1024 * 1024 {
+        return [5, 20, 50, Int32.max]
+    } else if diskSpace > 50 * 1024 * 1024 * 1024 {
+        return [5, 16, 32, Int32.max]
+    } else if diskSpace > 24 * 1024 * 1024 * 1024 {
+        return [2, 8, 16, Int32.max]
+    } else {
+        return [1, 4, 8, Int32.max]
+    }
+}()
+
+final class MaximumCacheSizePickerItem: ListViewItem, ItemListItem {
+    let theme: PresentationTheme
+    let strings: PresentationStrings
+    let value: Int32
+    let sectionId: ItemListSectionId
+    let updated: (Int32) -> Void
+    
+    init(theme: PresentationTheme, strings: PresentationStrings, value: Int32, sectionId: ItemListSectionId, updated: @escaping (Int32) -> Void) {
+        self.theme = theme
+        self.strings = strings
+        self.value = value
+        self.sectionId = sectionId
+        self.updated = updated
+    }
+    
+    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 = MaximumCacheSizePickerItemNode()
+            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 {
+            if let nodeValue = node() as? MaximumCacheSizePickerItemNode {
+                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 final class MaximumCacheSizePickerItemNode: ListViewItemNode {
+    private let backgroundNode: ASDisplayNode
+    private let topStripeNode: ASDisplayNode
+    private let bottomStripeNode: ASDisplayNode
+    private let maskNode: ASImageNode
+    
+    private let textNodes: [TextNode]
+    private var sliderView: TGPhotoEditorSliderView?
+    
+    private var item: MaximumCacheSizePickerItem?
+    private var layoutParams: ListViewItemLayoutParams?
+    
+    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()
+        
+        var textNodes: [TextNode] = []
+        for _ in 0 ..< 4 {
+            let textNode = TextNode()
+            textNode.isUserInteractionEnabled = false
+            textNode.displaysAsynchronously = false
+            textNodes.append(textNode)
+        }
+        self.textNodes = textNodes
+
+        super.init(layerBacked: false, dynamicBounce: false)
+        
+        for textNode in textNodes {
+            self.addSubnode(textNode)
+        }
+    }
+    
+    func updateSliderView() {
+        if let sliderView = self.sliderView, let item = self.item {
+            sliderView.maximumValue = 3.0
+            sliderView.positionsCount = 4
+            
+            let value = maximumCacheSizeValues.firstIndex(where: { $0 == item.value }) ?? 0
+            sliderView.value = CGFloat(value)
+        }
+    }
+    
+    override func didLoad() {
+        super.didLoad()
+        
+        let sliderView = TGPhotoEditorSliderView()
+        sliderView.enablePanHandling = true
+        sliderView.trackCornerRadius = 2.0
+        sliderView.lineSize = 4.0
+        sliderView.dotSize = 5.0
+        sliderView.minimumValue = 0.0
+        sliderView.maximumValue = 3.0
+        sliderView.startValue = 0.0
+        sliderView.disablesInteractiveTransitionGestureRecognizer = true
+        sliderView.positionsCount = 4
+        sliderView.useLinesForPositions = true
+        if let item = self.item, let params = self.layoutParams {
+            let value = maximumCacheSizeValues.firstIndex(where: { $0 == item.value }) ?? 0
+          
+            sliderView.value = CGFloat(value)
+            sliderView.backgroundColor = item.theme.list.itemBlocksBackgroundColor
+            sliderView.backColor = item.theme.list.itemSwitchColors.frameColor
+            sliderView.startColor = item.theme.list.itemSwitchColors.frameColor
+            sliderView.trackColor = item.theme.list.itemAccentColor
+            sliderView.knobImage = PresentationResourcesItemList.knobImage(item.theme)
+            
+            sliderView.frame = CGRect(origin: CGPoint(x: params.leftInset + 15.0, y: 37.0), size: CGSize(width: params.width - params.leftInset - params.rightInset - 15.0 * 2.0, height: 44.0))
+            sliderView.hitTestEdgeInsets = UIEdgeInsets(top: -sliderView.frame.minX, left: 0.0, bottom: 0.0, right: -sliderView.frame.minX)
+        }
+        self.view.addSubview(sliderView)
+        sliderView.addTarget(self, action: #selector(self.sliderValueChanged), for: .valueChanged)
+        self.sliderView = sliderView
+        
+        self.updateSliderView()
+    }
+    
+    func asyncLayout() -> (_ item: MaximumCacheSizePickerItem, _ params: ListViewItemLayoutParams, _ neighbors: ItemListNeighbors) -> (ListViewItemNodeLayout, () -> Void) {
+        let currentItem = self.item
+        var makeTextLayouts: [(TextNodeLayoutArguments) -> (TextNodeLayout, () -> TextNode)] = []
+        for textNode in self.textNodes {
+            makeTextLayouts.append(TextNode.asyncLayout(textNode))
+        }
+
+        return { item, params, neighbors in
+            var themeUpdated = false
+            if currentItem?.theme !== item.theme {
+                themeUpdated = true
+            }
+            
+            let contentSize: CGSize
+            let insets: UIEdgeInsets
+            let separatorHeight = UIScreenPixel
+            
+            var textLayouts: [TextNodeLayout] = []
+            var textApplies: [() -> TextNode] = []
+                                    
+            for i in 0 ..< makeTextLayouts.count {
+                let makeTextLayout = makeTextLayouts[i]
+                let (textLayout, textApply) = makeTextLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: stringForCacheSize(strings: item.strings, size: maximumCacheSizeValues[i]), font: Font.regular(13.0), textColor: item.theme.list.itemSecondaryTextColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width, height: CGFloat.greatestFiniteMagnitude), alignment: .center, lineSpacing: 0.0, cutout: nil, insets: UIEdgeInsets()))
+                textLayouts.append(textLayout)
+                textApplies.append(textApply)
+            }
+            
+            contentSize = CGSize(width: params.width, height: 88.0)
+            insets = itemListNeighborsGroupedInsets(neighbors, params)
+            
+            let layout = ListViewItemNodeLayout(contentSize: contentSize, insets: insets)
+            let layoutSize = layout.size
+            
+            return (layout, { [weak self] in
+                if let strongSelf = self {
+                    strongSelf.item = item
+                    strongSelf.layoutParams = params
+                    
+                    strongSelf.backgroundNode.backgroundColor = item.theme.list.itemBlocksBackgroundColor
+                    strongSelf.topStripeNode.backgroundColor = item.theme.list.itemBlocksSeparatorColor
+                    strongSelf.bottomStripeNode.backgroundColor = item.theme.list.itemBlocksSeparatorColor
+                    
+                    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.insertSubnode(strongSelf.maskNode, at: 3)
+                    }
+                    
+                    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 = 0.0
+                        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.theme, top: hasTopCorners, bottom: hasBottomCorners) : 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.maskNode.frame = strongSelf.backgroundNode.frame.insetBy(dx: params.leftInset, dy: 0.0)
+                    strongSelf.topStripeNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: layoutSize.width, height: separatorHeight))
+                    strongSelf.bottomStripeNode.frame = CGRect(origin: CGPoint(x: bottomStripeInset, y: contentSize.height + bottomStripeOffset), size: CGSize(width: layoutSize.width - bottomStripeInset, height: separatorHeight))
+                    
+                    for apply in textApplies {
+                        let _ = apply()
+                    }
+                    
+                    var textNodes: [(TextNode, CGSize)] = []
+                    for (node, size) in zip(strongSelf.textNodes, textLayouts.map { $0.size }) {
+                        textNodes.append((node, size))
+                    }
+                    
+                    let delta = (params.width - params.leftInset - params.rightInset - 18.0 * 2.0) / CGFloat(textNodes.count - 1)
+                    for i in 0 ..< textNodes.count {
+                        let (textNode, textSize) = textNodes[i]
+                        
+                        var position = params.leftInset + 18.0 + delta * CGFloat(i)
+                        if i == textNodes.count - 1 {
+                            position -= textSize.width
+                        } else if i > 0 {
+                            position -= textSize.width / 2.0
+                        }
+                        
+                        textNode.frame = CGRect(origin: CGPoint(x: position, y: 15.0), size: textSize)
+                    }
+                    
+                    if let sliderView = strongSelf.sliderView {
+                        if themeUpdated {
+                            sliderView.backgroundColor = item.theme.list.itemBlocksBackgroundColor
+                            sliderView.backColor = item.theme.list.itemSwitchColors.frameColor
+                            sliderView.startColor = item.theme.list.itemSwitchColors.frameColor
+                            sliderView.trackColor = item.theme.list.itemAccentColor
+                            sliderView.knobImage = PresentationResourcesItemList.knobImage(item.theme)
+                        }
+                        
+                        sliderView.frame = CGRect(origin: CGPoint(x: params.leftInset + 15.0, y: 37.0), size: CGSize(width: params.width - params.leftInset - params.rightInset - 15.0 * 2.0, height: 44.0))
+                        sliderView.hitTestEdgeInsets = UIEdgeInsets(top: -sliderView.frame.minX, left: 0.0, bottom: 0.0, right: -sliderView.frame.minX)
+                        
+                        strongSelf.updateSliderView()
+                    }
+                }
+            })
+        }
+    }
+    
+    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 sliderValueChanged() {
+        guard let sliderView = self.sliderView else {
+            return
+        }
+        
+        let position = Int(sliderView.value)
+        let value = maximumCacheSizeValues[position]
+        self.item?.updated(value)
+    }
+}
+

submodules/SettingsUI/Sources/Data and Storage/ProxyListSettingsController.swift

@@ -0,0 +1,534 @@
+import Foundation
+import UIKit
+import Display
+import SwiftSignalKit
+import Postbox
+import TelegramCore
+import TelegramPresentationData
+import MtProtoKit
+import ItemListUI
+import PresentationDataUtils
+import AccountContext
+import UrlEscaping
+import ShareController
+
+private final class ProxySettingsControllerArguments {
+    let toggleEnabled: (Bool) -> Void
+    let addNewServer: () -> Void
+    let activateServer: (ProxyServerSettings) -> Void
+    let editServer: (ProxyServerSettings) -> Void
+    let removeServer: (ProxyServerSettings) -> Void
+    let setServerWithRevealedOptions: (ProxyServerSettings?, ProxyServerSettings?) -> Void
+    let toggleUseForCalls: (Bool) -> Void
+    let shareProxyList: () -> Void
+    
+    init(toggleEnabled: @escaping (Bool) -> Void, addNewServer: @escaping () -> Void, activateServer: @escaping (ProxyServerSettings) -> Void, editServer: @escaping (ProxyServerSettings) -> Void, removeServer: @escaping (ProxyServerSettings) -> Void, setServerWithRevealedOptions: @escaping (ProxyServerSettings?, ProxyServerSettings?) -> Void, toggleUseForCalls: @escaping (Bool) -> Void, shareProxyList: @escaping () -> Void) {
+        self.toggleEnabled = toggleEnabled
+        self.addNewServer = addNewServer
+        self.activateServer = activateServer
+        self.editServer = editServer
+        self.removeServer = removeServer
+        self.setServerWithRevealedOptions = setServerWithRevealedOptions
+        self.toggleUseForCalls = toggleUseForCalls
+        self.shareProxyList = shareProxyList
+    }
+}
+
+private enum ProxySettingsControllerSection: Int32 {
+    case enabled
+    case servers
+    case share
+    case calls
+}
+
+private enum ProxyServerAvailabilityStatus: Equatable {
+    case checking
+    case notAvailable
+    case available(Int32)
+}
+
+private struct DisplayProxyServerStatus: Equatable {
+    let activity: Bool
+    let text: String
+    let textActive: Bool
+}
+
+private enum ProxySettingsControllerEntryId: Equatable, Hashable {
+    case index(Int)
+    case server(String, Int32, ProxyServerConnection)
+}
+
+private enum ProxySettingsControllerEntry: ItemListNodeEntry {
+    case enabled(PresentationTheme, String, Bool, Bool)
+    case serversHeader(PresentationTheme, String)
+    case addServer(PresentationTheme, String, Bool)
+    case server(Int, PresentationTheme, PresentationStrings, ProxyServerSettings, Bool, DisplayProxyServerStatus, ProxySettingsServerItemEditing, Bool)
+    case shareProxyList(PresentationTheme, String)
+    case useForCalls(PresentationTheme, String, Bool)
+    case useForCallsInfo(PresentationTheme, String)
+    
+    var section: ItemListSectionId {
+        switch self {
+            case .enabled:
+                return ProxySettingsControllerSection.enabled.rawValue
+            case .serversHeader, .addServer, .server:
+                return ProxySettingsControllerSection.servers.rawValue
+            case .shareProxyList:
+                return ProxySettingsControllerSection.share.rawValue
+            case .useForCalls, .useForCallsInfo:
+                return ProxySettingsControllerSection.calls.rawValue
+        }
+    }
+    
+    var stableId: ProxySettingsControllerEntryId {
+        switch self {
+            case .enabled:
+                return .index(0)
+            case .serversHeader:
+                return .index(1)
+            case .addServer:
+                return .index(2)
+            case let .server(_, _, _, settings, _, _, _, _):
+                return .server(settings.host, settings.port, settings.connection)
+            case .shareProxyList:
+                return .index(3)
+            case .useForCalls:
+                return .index(4)
+            case .useForCallsInfo:
+                return .index(5)
+        }
+    }
+    
+    static func ==(lhs: ProxySettingsControllerEntry, rhs: ProxySettingsControllerEntry) -> Bool {
+        switch lhs {
+            case let .enabled(lhsTheme, lhsText, lhsValue, lhsCreatesNew):
+                if case let .enabled(rhsTheme, rhsText, rhsValue, rhsCreatesNew) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue, lhsCreatesNew == rhsCreatesNew {
+                    return true
+                } else {
+                    return false
+                }
+            case let .serversHeader(lhsTheme, lhsText):
+                if case let .serversHeader(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .addServer(lhsTheme, lhsText, lhsEditing):
+                if case let .addServer(rhsTheme, rhsText, rhsEditing) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsEditing == rhsEditing {
+                    return true
+                } else {
+                    return false
+                }
+            case let .server(lhsIndex, lhsTheme, lhsStrings, lhsSettings, lhsActive, lhsStatus, lhsEditing, lhsEnabled):
+                if case let .server(rhsIndex, rhsTheme, rhsStrings, rhsSettings, rhsActive, rhsStatus, rhsEditing, rhsEnabled) = rhs, lhsIndex == rhsIndex, lhsTheme === rhsTheme, lhsStrings === rhsStrings, lhsSettings == rhsSettings, lhsActive == rhsActive, lhsStatus == rhsStatus, lhsEditing == rhsEditing, lhsEnabled == rhsEnabled {
+                    return true
+                } else {
+                    return false
+                }
+            case let .shareProxyList(lhsTheme, lhsText):
+                if case let .shareProxyList(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .useForCalls(lhsTheme, lhsText, lhsValue):
+                if case let .useForCalls(rhsTheme, rhsText, rhsValue) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue {
+                    return true
+                } else {
+                    return false
+                }
+            case let .useForCallsInfo(lhsTheme, lhsText):
+                if case let .useForCallsInfo(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+        }
+    }
+    
+    static func <(lhs: ProxySettingsControllerEntry, rhs: ProxySettingsControllerEntry) -> Bool {
+        switch lhs {
+            case .enabled:
+                switch rhs {
+                    case .enabled:
+                        return false
+                    default:
+                        return true
+                }
+            case .serversHeader:
+                switch rhs {
+                    case .enabled, .serversHeader:
+                        return false
+                    default:
+                        return true
+                }
+            case .addServer:
+                switch rhs {
+                    case .enabled, .serversHeader, .addServer:
+                        return false
+                    default:
+                        return true
+                }
+            case let .server(lhsIndex, _, _, _, _, _, _, _):
+                switch rhs {
+                    case .enabled, .serversHeader, .addServer:
+                        return false
+                    case let .server(rhsIndex, _, _, _, _, _, _, _):
+                        return lhsIndex < rhsIndex
+                    default:
+                        return true
+                }
+            case .shareProxyList:
+                switch rhs {
+                    case .enabled, .serversHeader, .addServer, .server, .shareProxyList:
+                        return false
+                    default:
+                        return true
+            }
+            case .useForCalls:
+                switch rhs {
+                    case .enabled, .serversHeader, .addServer, .server, .shareProxyList, .useForCalls:
+                        return false
+                    default:
+                        return true
+                }
+            case .useForCallsInfo:
+                return false
+        }
+    }
+    
+    func item(presentationData: ItemListPresentationData, arguments: Any) -> ListViewItem {
+        let arguments = arguments as! ProxySettingsControllerArguments
+        switch self {
+            case let .enabled(_, text, value, createsNew):
+                return ItemListSwitchItem(presentationData: presentationData, systemStyle: .glass, title: text, value: value, enableInteractiveChanges: !createsNew, enabled: true, sectionId: self.section, style: .blocks, updated: { value in
+                    if createsNew {
+                        arguments.addNewServer()
+                    } else {
+                        arguments.toggleEnabled(value)
+                    }
+                })
+            case let .serversHeader(_, text):
+                return ItemListSectionHeaderItem(presentationData: presentationData, text: text, sectionId: self.section)
+            case let .addServer(_, text, _):
+                return ProxySettingsActionItem(presentationData: presentationData, systemStyle: .glass, title: text, icon: .add, sectionId: self.section, editing: false, action: {
+                    arguments.addNewServer()
+                })
+            case let .server(_, theme, strings, settings, active, status, editing, enabled):
+                return ProxySettingsServerItem(theme: theme, strings: strings, systemStyle: .glass, server: settings, activity: status.activity, active: active, color: enabled ? .accent : .secondary, label: status.text, labelAccent: status.textActive, editing: editing, sectionId: self.section, action: {
+                    arguments.activateServer(settings)
+                }, infoAction: {
+                    arguments.editServer(settings)
+                }, setServerWithRevealedOptions: { lhs, rhs in
+                    arguments.setServerWithRevealedOptions(lhs, rhs)
+                }, removeServer: { _ in
+                    arguments.removeServer(settings)
+                })
+            case let .shareProxyList(_, text):
+                return ProxySettingsActionItem(presentationData: presentationData, systemStyle: .glass, title: text, sectionId: self.section, editing: false, action: {
+                    arguments.shareProxyList()
+                })
+            case let .useForCalls(_, text, value):
+                return ItemListSwitchItem(presentationData: presentationData, systemStyle: .glass, title: text, value: value, enableInteractiveChanges: true, enabled: true, sectionId: self.section, style: .blocks, updated: { value in
+                    arguments.toggleUseForCalls(value)
+                })
+            case let .useForCallsInfo(_, text):
+                return ItemListTextItem(presentationData: presentationData, text: .plain(text), sectionId: self.section)
+        }
+    }
+}
+
+private func proxySettingsControllerEntries(theme: PresentationTheme, strings: PresentationStrings, state: ProxySettingsControllerState, proxySettings: ProxySettings, statuses: [ProxyServerSettings: ProxyServerStatus], connectionStatus: ConnectionStatus) -> [ProxySettingsControllerEntry] {
+    var entries: [ProxySettingsControllerEntry] = []
+
+    entries.append(.enabled(theme, strings.ChatSettings_ConnectionType_UseProxy, proxySettings.enabled, proxySettings.servers.isEmpty))
+    entries.append(.serversHeader(theme, strings.SocksProxySetup_SavedProxies))
+    entries.append(.addServer(theme, strings.SocksProxySetup_AddProxy, state.editing))
+    var index = 0
+    for server in proxySettings.servers {
+        let status: ProxyServerStatus = statuses[server] ?? .checking
+        let displayStatus: DisplayProxyServerStatus
+        if proxySettings.enabled && server == proxySettings.activeServer {
+            switch connectionStatus {
+                case .waitingForNetwork:
+                    displayStatus = DisplayProxyServerStatus(activity: true, text: strings.State_WaitingForNetwork.lowercased(), textActive: false)
+                case .connecting, .updating:
+                    displayStatus = DisplayProxyServerStatus(activity: true, text: strings.SocksProxySetup_ProxyStatusConnecting, textActive: false)
+                case .online:
+                    var text = strings.SocksProxySetup_ProxyStatusConnected
+                    if case let .available(rtt) = status {
+                        let pingTime: Int = Int(rtt * 1000.0)
+                        text = text + ", \(strings.SocksProxySetup_ProxyStatusPing("\(pingTime)").string)"
+                    }
+                    displayStatus = DisplayProxyServerStatus(activity: false, text: text, textActive: true)
+            }
+        } else {
+            var text: String
+            switch server.connection {
+                case .socks5:
+                    text = strings.ChatSettings_ConnectionType_UseSocks5
+                case .mtp:
+                    text = strings.SocksProxySetup_ProxyTelegram
+            }
+            switch status {
+                case .notAvailable:
+                    text = text + ", " + strings.SocksProxySetup_ProxyStatusUnavailable
+                    displayStatus = DisplayProxyServerStatus(activity: false, text: text, textActive: false)
+                case .checking:
+                    text = text + ", " + strings.SocksProxySetup_ProxyStatusChecking
+                    displayStatus = DisplayProxyServerStatus(activity: false, text: text, textActive: false)
+                case let .available(rtt):
+                    let pingTime: Int = Int(rtt * 1000.0)
+                    text = text + ", \(strings.SocksProxySetup_ProxyStatusPing("\(pingTime)").string)"
+                    displayStatus = DisplayProxyServerStatus(activity: false, text: text, textActive: false)
+            }
+        }
+        entries.append(.server(index, theme, strings, server, server == proxySettings.activeServer, displayStatus, ProxySettingsServerItemEditing(editable: true, editing: state.editing, revealed: state.revealedServer == server), proxySettings.enabled))
+        index += 1
+    }
+    if !proxySettings.servers.isEmpty {
+        entries.append(.shareProxyList(theme, strings.SocksProxySetup_ShareProxyList))
+    }
+    
+    if let activeServer = proxySettings.activeServer, case .socks5 = activeServer.connection {
+        entries.append(.useForCalls(theme, strings.SocksProxySetup_UseForCalls, proxySettings.useForCalls))
+        entries.append(.useForCallsInfo(theme, strings.SocksProxySetup_UseForCallsHelp))
+    }
+    
+    return entries
+}
+
+private struct ProxySettingsControllerState: Equatable {
+    var editing: Bool = false
+    var revealedServer: ProxyServerSettings? = nil
+}
+
+public enum ProxySettingsControllerMode {
+    case `default`
+    case modal
+}
+
+public func proxySettingsController(context: AccountContext, mode: ProxySettingsControllerMode = .default) -> ViewController {
+    let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+    return proxySettingsController(accountManager: context.sharedContext.accountManager, sharedContext: context.sharedContext, context: context, postbox: context.account.postbox, network: context.account.network, mode: mode, presentationData: presentationData, updatedPresentationData: context.sharedContext.presentationData)
+}
+
+public func proxySettingsController(accountManager: AccountManager<TelegramAccountManagerTypes>, sharedContext: SharedAccountContext, context: AccountContext? = nil, postbox: Postbox, network: Network, mode: ProxySettingsControllerMode, presentationData: PresentationData, updatedPresentationData: Signal<PresentationData, NoError>) -> ViewController {
+    var pushControllerImpl: ((ViewController) -> Void)?
+    var dismissImpl: (() -> Void)?
+    let stateValue = Atomic(value: ProxySettingsControllerState())
+    let statePromise = ValuePromise<ProxySettingsControllerState>(stateValue.with { $0 })
+    let updateState: ((ProxySettingsControllerState) -> ProxySettingsControllerState) -> Void = { f in
+        var changed = false
+        let value = stateValue.modify { current in
+            let updated = f(current)
+            if updated != current {
+                changed = true
+            }
+            return updated
+        }
+        if changed {
+            statePromise.set(value)
+        }
+    }
+    
+    var shareProxyListImpl: (() -> Void)?
+    
+    let arguments = ProxySettingsControllerArguments(toggleEnabled: { value in
+        let _ = updateProxySettingsInteractively(accountManager: accountManager, { current in
+            var current = current
+            current.enabled = value
+            return current
+        }).start()
+    }, addNewServer: {
+        pushControllerImpl?(proxyServerSettingsController(sharedContext: sharedContext, presentationData: presentationData, updatedPresentationData: updatedPresentationData, accountManager: accountManager, network: network, currentSettings: nil))
+    }, activateServer: { server in
+        let _ = updateProxySettingsInteractively(accountManager: accountManager, { current in
+            var current = current
+            if current.activeServer != server {
+                if let _ = current.servers.firstIndex(of: server) {
+                    current.activeServer = server
+                    current.enabled = true
+                }
+            }
+            return current
+        }).start()
+    }, editServer: { server in
+        pushControllerImpl?(proxyServerSettingsController(sharedContext: sharedContext, presentationData: presentationData, updatedPresentationData: updatedPresentationData, accountManager: accountManager, network: network, currentSettings: server))
+    }, removeServer: { server in
+        let _ = updateProxySettingsInteractively(accountManager: accountManager, { current in
+            var current = current
+            if let index = current.servers.firstIndex(of: server) {
+                current.servers.remove(at: index)
+                if current.activeServer == server {
+                    current.activeServer = nil
+                    current.enabled = false
+                }
+            }
+            return current
+        }).start()
+    }, setServerWithRevealedOptions: { server, fromServer in
+        updateState { state in
+            var state = state
+            if (server == nil && fromServer == state.revealedServer) || (server != nil && fromServer == nil) {
+                state.revealedServer = server
+            }
+            return state
+        }
+    }, toggleUseForCalls: { value in
+        let _ = updateProxySettingsInteractively(accountManager: accountManager, { current in
+            var current = current
+            current.useForCalls = value
+            return current
+        }).start()
+    }, shareProxyList: {
+       shareProxyListImpl?()
+    })
+    
+    let proxySettings = Promise<ProxySettings>()
+    proxySettings.set(accountManager.sharedData(keys: [SharedDataKeys.proxySettings])
+    |> map { sharedData -> ProxySettings in
+        if let value = sharedData.entries[SharedDataKeys.proxySettings]?.get(ProxySettings.self) {
+            return value
+        } else {
+            return ProxySettings.defaultSettings
+        }
+    })
+    
+    let statusesContext = ProxyServersStatuses(network: network, servers: proxySettings.get()
+    |> map { proxySettings -> [ProxyServerSettings] in
+        return proxySettings.servers
+    })
+    
+    let signal = combineLatest(updatedPresentationData, statePromise.get(), proxySettings.get(), statusesContext.statuses(), network.connectionStatus)
+    |> map { presentationData, state, proxySettings, statuses, connectionStatus -> (ItemListControllerState, (ItemListNodeState, Any)) in
+        var leftNavigationButton: ItemListNavigationButton?
+        if case .modal = mode {
+            leftNavigationButton = ItemListNavigationButton(content: .text(presentationData.strings.Common_Cancel), style: .regular, enabled: true, action: {
+                dismissImpl?()
+            })
+        }
+        
+        let rightNavigationButton: ItemListNavigationButton?
+        if proxySettings.servers.isEmpty {
+            rightNavigationButton = nil
+        } else if state.editing {
+            rightNavigationButton = ItemListNavigationButton(content: .text(presentationData.strings.Common_Done), style: .bold, enabled: true, action: {
+                updateState { state in
+                    var state = state
+                    state.editing = false
+                    return state
+                }
+            })
+        } else {
+            rightNavigationButton = ItemListNavigationButton(content: .text(presentationData.strings.Common_Edit), style: .regular, enabled: true, action: {
+                updateState { state in
+                    var state = state
+                    state.editing = true
+                    return state
+                }
+            })
+        }
+        
+        let controllerState = ItemListControllerState(presentationData: ItemListPresentationData(presentationData), title: .text(presentationData.strings.SocksProxySetup_Title), leftNavigationButton: leftNavigationButton, rightNavigationButton: rightNavigationButton, backNavigationButton: ItemListBackButton(title: presentationData.strings.Common_Back))
+        let listState = ItemListNodeState(presentationData: ItemListPresentationData(presentationData), entries: proxySettingsControllerEntries(theme: presentationData.theme, strings: presentationData.strings, state: state, proxySettings: proxySettings, statuses: statuses, connectionStatus: connectionStatus), style: .blocks)
+        
+        return (controllerState, (listState, arguments))
+    }
+    
+    let controller = ItemListController(presentationData: ItemListPresentationData(presentationData), updatedPresentationData: updatedPresentationData |> map(ItemListPresentationData.init(_:)), state: signal, tabBarItem: nil)
+    controller.navigationPresentation = .modal
+    pushControllerImpl = { [weak controller] c in
+        (controller?.navigationController as? NavigationController)?.pushViewController(c)
+    }
+    dismissImpl = { [weak controller] in
+        controller?.dismiss()
+    }
+    controller.setReorderEntry({ (fromIndex: Int, toIndex: Int, entries: [ProxySettingsControllerEntry]) -> Signal<Bool, NoError> in
+        let fromEntry = entries[fromIndex]
+        guard case let .server(_, _, _, fromServer, _, _, _, _) = fromEntry else {
+            return .single(false)
+        }
+        var referenceServer: ProxyServerSettings?
+        var beforeAll = false
+        var afterAll = false
+        if toIndex < entries.count {
+            switch entries[toIndex] {
+                case let .server(_, _, _, toServer, _, _, _, _):
+                    referenceServer = toServer
+                default:
+                    if entries[toIndex] < fromEntry {
+                        beforeAll = true
+                    } else {
+                        afterAll = true
+                    }
+            }
+        } else {
+            afterAll = true
+        }
+
+        return updateProxySettingsInteractively(accountManager: accountManager, { current in
+            var current = current
+            if let index = current.servers.firstIndex(of: fromServer) {
+                current.servers.remove(at: index)
+            }
+            if let referenceServer = referenceServer {
+                var inserted = false
+                for i in 0 ..< current.servers.count {
+                    if current.servers[i] == referenceServer {
+                        if fromIndex < toIndex {
+                            current.servers.insert(fromServer, at: i + 1)
+                        } else {
+                            current.servers.insert(fromServer, at: i)
+                        }
+                        inserted = true
+                        break
+                    }
+                }
+                if !inserted {
+                    current.servers.append(fromServer)
+                }
+            } else if beforeAll {
+                current.servers.insert(fromServer, at: 0)
+            } else if afterAll {
+                current.servers.append(fromServer)
+            }
+            return current
+        })
+    })
+    
+    shareProxyListImpl = { [weak controller] in
+        guard let context = context, let strongController = controller else {
+            return
+        }
+        let _ = (proxySettings.get()
+            |> take(1)
+            |> deliverOnMainQueue).start(next: { settings in
+                var result = ""
+                for server in settings.servers {
+                    if !result.isEmpty {
+                        result += "\n\n"
+                    }
+                    
+                    var string: String
+                    switch server.connection {
+                    case let .mtp(secret):
+                        let secret = MTProxySecret.parseData(secret)?.serializeToString() ?? ""
+                        string = "https://t.me/proxy?server=\(server.host)&port=\(server.port)"
+                        string += "&secret=\((secret as NSString).addingPercentEncoding(withAllowedCharacters: CharacterSet.urlQueryValueAllowed) ?? "")"
+                    case let .socks5(username, password):
+                        string = "https://t.me/socks?server=\(server.host)&port=\(server.port)"
+                        if let username = username, let password = password {
+                            string += "&user=\((username as NSString).addingPercentEncoding(withAllowedCharacters: CharacterSet.urlQueryValueAllowed) ?? "")&pass=\((password as NSString).addingPercentEncoding(withAllowedCharacters: CharacterSet.urlQueryValueAllowed) ?? "")"
+                        }
+                    }
+                    
+                    result += string
+                }
+                
+                presentExternalShare(context: context, text: result, parentController: strongController)
+            })
+    }
+    
+    return controller
+}

submodules/SettingsUI/Sources/Data and Storage/ProxyServerActionSheetController.swift

@@ -0,0 +1,440 @@
+import Foundation
+import UIKit
+import Display
+import TelegramCore
+import Postbox
+import AsyncDisplayKit
+import UIKit
+import SwiftSignalKit
+import TelegramPresentationData
+import ActivityIndicator
+import OverlayStatusController
+import AccountContext
+import PresentationDataUtils
+import UrlEscaping
+
+public final class ProxyServerActionSheetController: ActionSheetController {
+    private var presentationDisposable: Disposable?
+    
+    private let _ready = Promise<Bool>()
+    override public var ready: Promise<Bool> {
+        return self._ready
+    }
+    
+    private var isDismissed: Bool = false
+    
+    convenience public init(context: AccountContext, server: ProxyServerSettings) {
+        let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+        self.init(presentationData: presentationData, accountManager: context.sharedContext.accountManager, postbox: context.account.postbox, network: context.account.network, server: server, updatedPresentationData: context.sharedContext.presentationData)
+    }
+    
+    public init(presentationData: PresentationData, accountManager: AccountManager<TelegramAccountManagerTypes>, postbox: Postbox, network: Network, server: ProxyServerSettings, updatedPresentationData: Signal<PresentationData, NoError>?) {
+        let sheetTheme = ActionSheetControllerTheme(presentationData: presentationData)
+        super.init(theme: sheetTheme)
+        
+        self._ready.set(.single(true))
+        
+        var items: [ActionSheetItem] = []
+        if case .mtp = server.connection {
+            items.append(ActionSheetTextItem(title: presentationData.strings.SocksProxySetup_AdNoticeHelp))
+        }
+        items.append(ProxyServerInfoItem(strings: presentationData.strings, network: network, server: server))
+        items.append(ProxyServerActionItem(accountManager:accountManager, postbox: postbox, network: network, presentationData: presentationData, server: server, dismiss: { [weak self] success in
+            guard let strongSelf = self, !strongSelf.isDismissed else {
+                return
+            }
+            strongSelf.isDismissed = true
+            if success {
+                strongSelf.present(OverlayStatusController(theme: presentationData.theme, type: .shieldSuccess(presentationData.strings.SocksProxySetup_ProxyEnabled, false)), in: .window(.root))
+            }
+            strongSelf.dismissAnimated()
+        }, present: { [weak self] c, a in
+            self?.present(c, in: .window(.root), with: a)
+        }))
+        self.setItemGroups([
+            ActionSheetItemGroup(items: items),
+            ActionSheetItemGroup(items: [
+                ActionSheetButtonItem(title: presentationData.strings.Common_Cancel, action: { [weak self] in
+                    self?.dismissAnimated()
+                })
+            ])
+        ])
+        
+        if let updatedPresentationData = updatedPresentationData {
+            self.presentationDisposable = updatedPresentationData.start(next: { [weak self] presentationData in
+                if let strongSelf = self {
+                    strongSelf.theme = ActionSheetControllerTheme(presentationData: presentationData)
+                }
+            })
+        }
+    }
+    
+    required public init(coder aDecoder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+    
+    deinit {
+        self.presentationDisposable?.dispose()
+    }
+}
+
+private final class ProxyServerInfoItem: ActionSheetItem {
+    private let strings: PresentationStrings
+    private let network: Network
+    private let server: ProxyServerSettings
+    
+    init(strings: PresentationStrings, network: Network, server: ProxyServerSettings) {
+        self.strings = strings
+        self.network = network
+        self.server = server
+    }
+    
+    func node(theme: ActionSheetControllerTheme) -> ActionSheetItemNode {
+        return ProxyServerInfoItemNode(theme: theme, strings: self.strings, network: self.network, server: self.server)
+    }
+    
+    func updateNode(_ node: ActionSheetItemNode) {
+    }
+}
+
+private enum ProxyServerInfoStatusType {
+    case generic(String)
+    case failed(String)
+}
+
+private final class ProxyServerInfoItemNode: ActionSheetItemNode {
+    private let theme: ActionSheetControllerTheme
+    private let strings: PresentationStrings
+    private let textFont: UIFont
+    
+    private let network: Network
+    private let server: ProxyServerSettings
+    
+    private let fieldNodes: [(ImmediateTextNode, ImmediateTextNode)]
+    private let statusTextNode: ImmediateTextNode
+    
+    private let statusDisposable = MetaDisposable()
+    
+    init(theme: ActionSheetControllerTheme, strings: PresentationStrings, network: Network, server: ProxyServerSettings) {
+        self.theme = theme
+        self.strings = strings
+        self.network = network
+        self.server = server
+        
+        self.textFont = Font.regular(floor(theme.baseFontSize * 16.0 / 17.0))
+        
+        var fieldNodes: [(ImmediateTextNode, ImmediateTextNode)] = []
+        let serverTitleNode = ImmediateTextNode()
+        serverTitleNode.isUserInteractionEnabled = false
+        serverTitleNode.displaysAsynchronously = false
+        serverTitleNode.attributedText = NSAttributedString(string: strings.SocksProxySetup_Hostname, font: textFont, textColor: theme.secondaryTextColor)
+        let serverTextNode = ImmediateTextNode()
+        serverTextNode.isUserInteractionEnabled = false
+        serverTextNode.displaysAsynchronously = false
+        serverTextNode.attributedText = NSAttributedString(string: urlEncodedStringFromString(server.host), font: textFont, textColor: theme.primaryTextColor)
+        fieldNodes.append((serverTitleNode, serverTextNode))
+        
+        let portTitleNode = ImmediateTextNode()
+        portTitleNode.isUserInteractionEnabled = false
+        portTitleNode.displaysAsynchronously = false
+        portTitleNode.attributedText = NSAttributedString(string: strings.SocksProxySetup_Port, font: textFont, textColor: theme.secondaryTextColor)
+        let portTextNode = ImmediateTextNode()
+        portTextNode.isUserInteractionEnabled = false
+        portTextNode.displaysAsynchronously = false
+        portTextNode.attributedText = NSAttributedString(string: "\(server.port)", font: textFont, textColor: theme.primaryTextColor)
+        fieldNodes.append((portTitleNode, portTextNode))
+        
+        switch server.connection {
+            case let .socks5(username, password):
+                if let username = username {
+                    let usernameTitleNode = ImmediateTextNode()
+                    usernameTitleNode.isUserInteractionEnabled = false
+                    usernameTitleNode.displaysAsynchronously = false
+                    usernameTitleNode.attributedText = NSAttributedString(string: strings.SocksProxySetup_Username, font: textFont, textColor: theme.secondaryTextColor)
+                    let usernameTextNode = ImmediateTextNode()
+                    usernameTextNode.isUserInteractionEnabled = false
+                    usernameTextNode.displaysAsynchronously = false
+                    usernameTextNode.attributedText = NSAttributedString(string: username, font: textFont, textColor: theme.primaryTextColor)
+                    fieldNodes.append((usernameTitleNode, usernameTextNode))
+                }
+                
+                if let password = password {
+                    let passwordTitleNode = ImmediateTextNode()
+                    passwordTitleNode.isUserInteractionEnabled = false
+                    passwordTitleNode.displaysAsynchronously = false
+                    passwordTitleNode.attributedText = NSAttributedString(string: strings.SocksProxySetup_Password, font: textFont, textColor: theme.secondaryTextColor)
+                    let passwordTextNode = ImmediateTextNode()
+                    passwordTextNode.isUserInteractionEnabled = false
+                    passwordTextNode.displaysAsynchronously = false
+                    passwordTextNode.attributedText = NSAttributedString(string: password, font: textFont, textColor: theme.primaryTextColor)
+                    fieldNodes.append((passwordTitleNode, passwordTextNode))
+                }
+            case .mtp:
+                let passwordTitleNode = ImmediateTextNode()
+                passwordTitleNode.isUserInteractionEnabled = false
+                passwordTitleNode.displaysAsynchronously = false
+                passwordTitleNode.attributedText = NSAttributedString(string: strings.SocksProxySetup_Secret, font: textFont, textColor: theme.secondaryTextColor)
+                let passwordTextNode = ImmediateTextNode()
+                passwordTextNode.isUserInteractionEnabled = false
+                passwordTextNode.displaysAsynchronously = false
+                passwordTextNode.attributedText = NSAttributedString(string: "•••••", font: textFont, textColor: theme.primaryTextColor)
+                fieldNodes.append((passwordTitleNode, passwordTextNode))
+        }
+        
+        let statusTitleNode = ImmediateTextNode()
+        statusTitleNode.isUserInteractionEnabled = false
+        statusTitleNode.displaysAsynchronously = false
+        statusTitleNode.attributedText = NSAttributedString(string: strings.SocksProxySetup_Status, font: textFont, textColor: theme.secondaryTextColor)
+        let statusTextNode = ImmediateTextNode()
+        statusTextNode.isUserInteractionEnabled = false
+        statusTextNode.displaysAsynchronously = false
+        statusTextNode.attributedText = NSAttributedString(string: strings.SocksProxySetup_ProxyStatusChecking, font: textFont, textColor: theme.primaryTextColor)
+        fieldNodes.append((statusTitleNode, statusTextNode))
+        
+        self.fieldNodes = fieldNodes
+        self.statusTextNode = statusTextNode
+        
+        super.init(theme: theme)
+        
+        for (lhs, rhs) in fieldNodes {
+            self.addSubnode(lhs)
+            self.addSubnode(rhs)
+        }
+    }
+    
+    deinit {
+        self.statusDisposable.dispose()
+    }
+    
+    override func didLoad() {
+        super.didLoad()
+        
+        let statusesContext = ProxyServersStatuses(network: network, servers: .single([self.server]))
+        self.statusDisposable.set((statusesContext.statuses()
+        |> map { return $0.first?.value }
+        |> distinctUntilChanged
+        |> deliverOnMainQueue).start(next: { [weak self] status in
+            if let strongSelf = self, let status = status {
+                let statusType: ProxyServerInfoStatusType
+                switch status {
+                    case .checking:
+                        statusType = .generic(strongSelf.strings.SocksProxySetup_ProxyStatusChecking)
+                    case let .available(rtt):
+                        let pingTime = Int(rtt * 1000.0)
+                        statusType = .generic(strongSelf.strings.SocksProxySetup_ProxyStatusPing("\(pingTime)").string)
+                    case .notAvailable:
+                        statusType = .failed(strongSelf.strings.SocksProxySetup_ProxyStatusUnavailable)
+                }
+                strongSelf.setStatus(statusType)
+            }
+        }))
+    }
+    
+    func setStatus(_ status: ProxyServerInfoStatusType) {
+        let attributedString: NSAttributedString
+        switch status {
+            case let .generic(text):
+                attributedString = NSAttributedString(string: text, font: textFont, textColor: theme.primaryTextColor)
+            case let .failed(text):
+                attributedString = NSAttributedString(string: text, font: textFont, textColor: theme.destructiveActionTextColor)
+        }
+        self.statusTextNode.attributedText = attributedString
+        self.requestLayoutUpdate()
+    }
+    
+    public override func updateLayout(constrainedSize: CGSize, transition: ContainedViewLayoutTransition) -> CGSize {
+        let size = CGSize(width: constrainedSize.width, height: 36.0 * CGFloat(self.fieldNodes.count) + 12.0)
+        
+        var offset: CGFloat = 15.0
+        for (lhs, rhs) in self.fieldNodes {
+            let lhsSize = lhs.updateLayout(CGSize(width: size.width - 18.0 * 2.0, height: CGFloat.greatestFiniteMagnitude))
+            lhs.frame = CGRect(origin: CGPoint(x: 18, y: offset), size: lhsSize)
+            
+            let rhsSize = rhs.updateLayout(CGSize(width: max(1.0, size.width - 18 * 2.0 - lhsSize.width - 4.0), height: CGFloat.greatestFiniteMagnitude))
+            rhs.frame = CGRect(origin: CGPoint(x: size.width - 18 - rhsSize.width, y: offset), size: rhsSize)
+            
+            offset += 36.0
+        }
+  
+        self.updateInternalLayout(size, constrainedSize: constrainedSize)
+        return size
+    }
+}
+
+private final class ProxyServerActionItem: ActionSheetItem {
+    private let accountManager: AccountManager<TelegramAccountManagerTypes>
+    private let postbox: Postbox
+    private let network: Network
+    private let presentationData: PresentationData
+    private let server: ProxyServerSettings
+    private let dismiss: (Bool) -> Void
+    private let present: (ViewController, Any?) -> Void
+    
+    init(accountManager: AccountManager<TelegramAccountManagerTypes>, postbox: Postbox, network: Network, presentationData: PresentationData, server: ProxyServerSettings, dismiss: @escaping (Bool) -> Void, present: @escaping (ViewController, Any?) -> Void) {
+        self.accountManager = accountManager
+        self.postbox = postbox
+        self.network = network
+        self.presentationData = presentationData
+        self.server = server
+        self.dismiss = dismiss
+        self.present = present
+    }
+    
+    func node(theme: ActionSheetControllerTheme) -> ActionSheetItemNode {
+        return ProxyServerActionItemNode(accountManager: self.accountManager, postbox: self.postbox, network: self.network, presentationData: self.presentationData, theme: theme, server: self.server, dismiss: self.dismiss, present: self.present)
+    }
+    
+    func updateNode(_ node: ActionSheetItemNode) {
+    }
+}
+
+private final class ProxyServerActionItemNode: ActionSheetItemNode {
+    private let accountManager: AccountManager<TelegramAccountManagerTypes>
+    private let postbox: Postbox
+    private let network: Network
+    private let presentationData: PresentationData
+    private let theme: ActionSheetControllerTheme
+    private let server: ProxyServerSettings
+    private let dismiss: (Bool) -> Void
+    private let present: (ViewController, Any?) -> Void
+    
+    private let buttonNode: HighlightableButtonNode
+    private let titleNode: ImmediateTextNode
+    private let activityIndicator: ActivityIndicator
+    
+    private let disposable = MetaDisposable()
+    private var revertSettings: ProxySettings?
+    
+    init(accountManager: AccountManager<TelegramAccountManagerTypes>, postbox: Postbox, network: Network, presentationData: PresentationData, theme: ActionSheetControllerTheme, server: ProxyServerSettings, dismiss: @escaping (Bool) -> Void, present: @escaping (ViewController, Any?) -> Void) {
+        self.accountManager = accountManager
+        self.postbox = postbox
+        self.network = network
+        self.theme = theme
+        self.presentationData = presentationData
+        self.server = server
+        self.dismiss = dismiss
+        self.present = present
+        
+        let titleFont = Font.regular(floor(theme.baseFontSize * 20.0 / 17.0))
+        
+        self.titleNode = ImmediateTextNode()
+        self.titleNode.isUserInteractionEnabled = false
+        self.titleNode.displaysAsynchronously = false
+        self.titleNode.attributedText = NSAttributedString(string: presentationData.strings.SocksProxySetup_ConnectAndSave, font: titleFont, textColor: theme.controlAccentColor)
+        
+        self.activityIndicator = ActivityIndicator(type: .custom(theme.controlAccentColor, 22.0, 1.5, false))
+        self.activityIndicator.isHidden = true
+        
+        self.buttonNode = HighlightableButtonNode()
+        
+        super.init(theme: theme)
+        
+        self.addSubnode(self.titleNode)
+        self.addSubnode(self.activityIndicator)
+        self.addSubnode(self.buttonNode)
+        
+        self.buttonNode.highligthedChanged = { [weak self] highlighted in
+            if let strongSelf = self {
+                if highlighted {
+                    strongSelf.backgroundNode.backgroundColor = strongSelf.theme.itemHighlightedBackgroundColor
+                } else {
+                    UIView.animate(withDuration: 0.3, animations: {
+                        strongSelf.backgroundNode.backgroundColor = strongSelf.theme.itemBackgroundColor
+                    })
+                }
+            }
+        }
+        
+        self.buttonNode.addTarget(self, action: #selector(self.buttonPressed), forControlEvents: .touchUpInside)
+    }
+    
+    deinit {
+        self.disposable.dispose()
+        if let revertSettings = self.revertSettings {
+            let _ = updateProxySettingsInteractively(accountManager: self.accountManager, { _ in
+                return revertSettings
+            })
+        }
+    }
+    
+    public override func updateLayout(constrainedSize: CGSize, transition: ContainedViewLayoutTransition) -> CGSize {
+        let size = CGSize(width: constrainedSize.width, height: 57.0)
+        
+        self.buttonNode.frame = CGRect(origin: CGPoint(), size: size)
+        
+        let labelSize = self.titleNode.updateLayout(CGSize(width: max(1.0, size.width - 10.0), height: size.height))
+        let titleFrame = CGRect(origin: CGPoint(x: floorToScreenPixels((size.width - labelSize.width) / 2.0), y: floorToScreenPixels((size.height - labelSize.height) / 2.0)), size: labelSize)
+        let activitySize = self.activityIndicator.measure(CGSize(width: 100.0, height: 100.0))
+        self.titleNode.frame = titleFrame
+        self.activityIndicator.frame = CGRect(origin: CGPoint(x: 14.0, y: titleFrame.minY - 0.0), size: activitySize)
+        
+        self.updateInternalLayout(size, constrainedSize: constrainedSize)
+        return size
+    }
+
+    @objc private func buttonPressed() {
+        let proxyServerSettings = self.server
+        let _ = (self.accountManager.transaction { transaction -> ProxySettings in
+            var currentSettings: ProxySettings?
+            let _ = updateProxySettingsInteractively(transaction: transaction, { settings in
+                currentSettings = settings
+                var settings = settings
+                if let index = settings.servers.firstIndex(of: proxyServerSettings) {
+                    settings.servers[index] = proxyServerSettings
+                    settings.activeServer = proxyServerSettings
+                } else {
+                    settings.servers.insert(proxyServerSettings, at: 0)
+                    settings.activeServer = proxyServerSettings
+                }
+                settings.enabled = true
+                return settings
+            })
+            return currentSettings ?? ProxySettings.defaultSettings
+        } |> deliverOnMainQueue).start(next: { [weak self] previousSettings in
+            if let strongSelf = self {
+                strongSelf.revertSettings = previousSettings
+                strongSelf.buttonNode.isUserInteractionEnabled = false
+                strongSelf.titleNode.attributedText = NSAttributedString(string: strongSelf.presentationData.strings.SocksProxySetup_Connecting, font: Font.regular(20.0), textColor: strongSelf.theme.primaryTextColor)
+                strongSelf.activityIndicator.isHidden = false
+                strongSelf.requestLayoutUpdate()
+                
+                let signal = strongSelf.network.connectionStatus
+                |> filter { status in
+                    switch status {
+                        case let .online(proxyAddress):
+                            if proxyAddress == proxyServerSettings.host {
+                                return true
+                            } else {
+                                return false
+                            }
+                        default:
+                            return false
+                    }
+                }
+                |> map { _ -> Bool in
+                    return true
+                }
+                |> timeout(15.0, queue: Queue.mainQueue(), alternate: .single(false))
+                |> deliverOnMainQueue
+                strongSelf.disposable.set(signal.start(next: { value in
+                    if let strongSelf = self {
+                        strongSelf.activityIndicator.isHidden = true
+                        strongSelf.revertSettings = nil
+                        if value {
+                            strongSelf.dismiss(true)
+                        } else {
+                            let _ = updateProxySettingsInteractively(accountManager: strongSelf.accountManager, { _ in
+                                return previousSettings
+                            })
+                            strongSelf.titleNode.attributedText = NSAttributedString(string: strongSelf.presentationData.strings.SocksProxySetup_ConnectAndSave, font: Font.regular(20.0), textColor: strongSelf.theme.controlAccentColor)
+                            strongSelf.buttonNode.isUserInteractionEnabled = true
+                            strongSelf.requestLayoutUpdate()
+                            
+                            strongSelf.present(standardTextAlertController(theme: AlertControllerTheme(presentationData: strongSelf.presentationData), title: nil, text: strongSelf.presentationData.strings.SocksProxySetup_FailedToConnect, actions: [TextAlertAction(type: .defaultAction, title: strongSelf.presentationData.strings.Common_OK, action: {})]), nil)
+                        }
+                    }
+                }))
+            }
+        })
+    }
+}

submodules/SettingsUI/Sources/Data and Storage/ProxyServerSettingsController.swift

@@ -0,0 +1,392 @@
+import Foundation
+import UIKit
+import Display
+import SwiftSignalKit
+import TelegramCore
+import MtProtoKit
+import TelegramPresentationData
+import ItemListUI
+import PresentationDataUtils
+import AccountContext
+import UrlEscaping
+import UrlHandling
+import ShareController
+
+private func shareLink(for server: ProxyServerSettings) -> String {
+    var link: String
+    switch server.connection {
+    case let .mtp(secret):
+        let secret = MTProxySecret.parseData(secret)?.serializeToString() ?? ""
+        link = "https://t.me/proxy?server=\(server.host)&port=\(server.port)"
+        link += "&secret=\(secret.addingPercentEncoding(withAllowedCharacters: CharacterSet.urlQueryValueAllowed) ?? "")"
+    case let .socks5(username, password):
+        link = "https://t.me/socks?server=\(server.host)&port=\(server.port)"
+        link += "&user=\(username?.addingPercentEncoding(withAllowedCharacters: CharacterSet.urlQueryValueAllowed) ?? "")&pass=\(password?.addingPercentEncoding(withAllowedCharacters: CharacterSet.urlQueryValueAllowed) ?? "")"
+    }
+    return link
+}
+
+private final class ProxyServerSettingsControllerArguments {
+    let updateState: ((ProxyServerSettingsControllerState) -> ProxyServerSettingsControllerState) -> Void
+    let share: () -> Void
+    let usePasteboardSettings: () -> Void
+    
+    init(updateState: @escaping ((ProxyServerSettingsControllerState) -> ProxyServerSettingsControllerState) -> Void, share: @escaping () -> Void, usePasteboardSettings: @escaping () -> Void) {
+        self.updateState = updateState
+        self.share = share
+        self.usePasteboardSettings = usePasteboardSettings
+    }
+}
+
+private enum ProxySettingsSection: Int32 {
+    case pasteboard
+    case mode
+    case connection
+    case credentials
+    case share
+}
+
+private enum ProxySettingsEntry: ItemListNodeEntry {
+    case usePasteboardSettings(PresentationTheme, String)
+    case usePasteboardInfo(PresentationTheme, String)
+    
+    case modeSocks5(PresentationTheme, String, Bool)
+    case modeMtp(PresentationTheme, String, Bool)
+    
+    case connectionHeader(PresentationTheme, String)
+    case connectionServer(PresentationTheme, PresentationStrings, String, String)
+    case connectionPort(PresentationTheme, PresentationStrings, String, String)
+    
+    case credentialsHeader(PresentationTheme, String)
+    case credentialsUsername(PresentationTheme, PresentationStrings, String, String)
+    case credentialsPassword(PresentationTheme, PresentationStrings, String, String)
+    case credentialsSecret(PresentationTheme, PresentationStrings, String, String)
+    
+    case share(PresentationTheme, String, Bool)
+    
+    var section: ItemListSectionId {
+        switch self {
+            case .usePasteboardSettings, .usePasteboardInfo:
+                return ProxySettingsSection.pasteboard.rawValue
+            case .modeSocks5, .modeMtp:
+                return ProxySettingsSection.mode.rawValue
+            case .connectionHeader, .connectionServer, .connectionPort:
+                return ProxySettingsSection.connection.rawValue
+            case .credentialsHeader, .credentialsUsername, .credentialsPassword, .credentialsSecret:
+                return ProxySettingsSection.credentials.rawValue
+            case .share:
+                return ProxySettingsSection.share.rawValue
+        }
+    }
+    
+    var stableId: Int32 {
+        switch self {
+            case .usePasteboardSettings:
+                return 0
+            case .usePasteboardInfo:
+                return 1
+            case .modeSocks5:
+                return 2
+            case .modeMtp:
+                return 3
+            case .connectionHeader:
+                return 4
+            case .connectionServer:
+                return 5
+            case .connectionPort:
+                return 6
+            case .credentialsHeader:
+                return 7
+            case .credentialsUsername:
+                return 8
+            case .credentialsPassword:
+                return 9
+            case .credentialsSecret:
+                return 10
+            case .share:
+                return 12
+        }
+    }
+    
+    static func <(lhs: ProxySettingsEntry, rhs: ProxySettingsEntry) -> Bool {
+        return lhs.stableId < rhs.stableId
+    }
+    
+    func item(presentationData: ItemListPresentationData, arguments: Any) -> ListViewItem {
+        let arguments = arguments as! ProxyServerSettingsControllerArguments
+        switch self {
+            case let .usePasteboardSettings(_, title):
+                return ItemListActionItem(presentationData: presentationData, systemStyle: .glass, title: title, kind: .generic, alignment: .natural, sectionId: self.section, style: .blocks, action: {
+                    arguments.usePasteboardSettings()
+                })
+            case let .usePasteboardInfo(_, text):
+                return ItemListTextItem(presentationData: presentationData, text: .plain(text), sectionId: self.section)
+            case let .modeSocks5(_, text, value):
+                return ItemListCheckboxItem(presentationData: presentationData, systemStyle: .glass, title: text, style: .left, checked: value, zeroSeparatorInsets: false, sectionId: self.section, action: {
+                    arguments.updateState { state in
+                        var state = state
+                        state.mode = .socks5
+                        return state
+                    }
+                })
+            case let .modeMtp(_, text, value):
+                return ItemListCheckboxItem(presentationData: presentationData, systemStyle: .glass, title: text, style: .left, checked: value, zeroSeparatorInsets: false, sectionId: self.section, action: {
+                    arguments.updateState { state in
+                        var state = state
+                        state.mode = .mtp
+                        return state
+                    }
+                })
+            case let .connectionHeader(_, text):
+                return ItemListSectionHeaderItem(presentationData: presentationData, text: text, sectionId: self.section)
+            case let .connectionServer(_, _, placeholder, text):
+                return ItemListSingleLineInputItem(presentationData: presentationData, systemStyle: .glass, title: NSAttributedString(), text: text, placeholder: placeholder, type: .regular(capitalization: false, autocorrection: false), sectionId: self.section, textUpdated: { value in
+                    arguments.updateState { current in
+                        var state = current
+                        state.host = value
+                        return state
+                    }
+                }, action: {})
+            case let .connectionPort(_, _, placeholder, text):
+                return ItemListSingleLineInputItem(presentationData: presentationData, systemStyle: .glass, title: NSAttributedString(), text: text, placeholder: placeholder, type: .number, sectionId: self.section, textUpdated: { value in
+                    arguments.updateState { current in
+                        var state = current
+                        state.port = value
+                        return state
+                    }
+                }, action: {})
+            case let .credentialsHeader(_, text):
+                return ItemListSectionHeaderItem(presentationData: presentationData, text: text, sectionId: self.section)
+            case let .credentialsUsername(_, _, placeholder, text):
+                return ItemListSingleLineInputItem(presentationData: presentationData, systemStyle: .glass, title: NSAttributedString(), text: text, placeholder: placeholder, sectionId: self.section, textUpdated: { value in
+                    arguments.updateState { current in
+                        var state = current
+                        state.username = value
+                        return state
+                    }
+                }, action: {})
+            case let .credentialsPassword(_, _, placeholder, text):
+                return ItemListSingleLineInputItem(presentationData: presentationData, systemStyle: .glass, title: NSAttributedString(), text: text, placeholder: placeholder, type: .password, sectionId: self.section, textUpdated: { value in
+                    arguments.updateState { current in
+                        var state = current
+                        state.password = value
+                        return state
+                    }
+                }, action: {})
+            case let .credentialsSecret(_, _, placeholder, text):
+                return ItemListSingleLineInputItem(presentationData: presentationData, systemStyle: .glass, title: NSAttributedString(), text: text, placeholder: placeholder, type: .regular(capitalization: false, autocorrection: false), sectionId: self.section, textUpdated: { value in
+                    arguments.updateState { current in
+                        var state = current
+                        state.secret = value
+                        return state
+                    }
+                }, action: {})
+            case let .share(_, text, enabled):
+                return ItemListActionItem(presentationData: presentationData, systemStyle: .glass, title: text, kind: enabled ? .generic : .disabled, alignment: .natural, sectionId: self.section, style: .blocks, action: {
+                    arguments.share()
+                })
+        }
+    }
+}
+
+private enum ProxyServerSettingsControllerMode {
+    case socks5
+    case mtp
+}
+
+private struct ProxyServerSettingsControllerState: Equatable {
+    var mode: ProxyServerSettingsControllerMode
+    var host: String
+    var port: String
+    var username: String
+    var password: String
+    var secret: String
+    
+    var isComplete: Bool {
+        if self.host.isEmpty || self.port.isEmpty || Int(self.port) == nil {
+            return false
+        }
+        switch self.mode {
+            case .socks5:
+                break
+            case .mtp:
+                let secretIsValid = MTProxySecret.parse(self.secret) != nil
+                if !secretIsValid {
+                    return false
+                }
+        }
+        return true
+    }
+}
+
+private func proxyServerSettingsControllerEntries(presentationData: PresentationData, state: ProxyServerSettingsControllerState, pasteboardSettings: ProxyServerSettings?) -> [ProxySettingsEntry] {
+    var entries: [ProxySettingsEntry] = []
+    
+    if let _ = pasteboardSettings {
+        entries.append(.usePasteboardSettings(presentationData.theme, presentationData.strings.SocksProxySetup_PasteFromClipboard))
+    }
+    
+    entries.append(.modeSocks5(presentationData.theme, presentationData.strings.SocksProxySetup_ProxySocks5, state.mode == .socks5))
+    entries.append(.modeMtp(presentationData.theme, presentationData.strings.SocksProxySetup_ProxyTelegram, state.mode == .mtp))
+    
+    entries.append(.connectionHeader(presentationData.theme, presentationData.strings.SocksProxySetup_Connection.uppercased()))
+    entries.append(.connectionServer(presentationData.theme, presentationData.strings, presentationData.strings.SocksProxySetup_Hostname, state.host))
+    entries.append(.connectionPort(presentationData.theme, presentationData.strings, presentationData.strings.SocksProxySetup_Port, state.port))
+    
+    switch state.mode {
+        case .socks5:
+            entries.append(.credentialsHeader(presentationData.theme, presentationData.strings.SocksProxySetup_Credentials))
+            entries.append(.credentialsUsername(presentationData.theme, presentationData.strings, presentationData.strings.SocksProxySetup_Username, state.username))
+            entries.append(.credentialsPassword(presentationData.theme, presentationData.strings, presentationData.strings.SocksProxySetup_Password, state.password))
+        case .mtp:
+            entries.append(.credentialsHeader(presentationData.theme, presentationData.strings.SocksProxySetup_RequiredCredentials))
+            entries.append(.credentialsSecret(presentationData.theme, presentationData.strings, presentationData.strings.SocksProxySetup_SecretPlaceholder, state.secret))
+    }
+    
+    entries.append(.share(presentationData.theme, presentationData.strings.Conversation_ContextMenuShare, state.isComplete))
+    
+    return entries
+}
+
+private func proxyServerSettings(with state: ProxyServerSettingsControllerState) -> ProxyServerSettings? {
+    if state.isComplete, let port = Int32(state.port) {
+        switch state.mode {
+            case .socks5:
+                return ProxyServerSettings(host: state.host, port: port, connection: .socks5(username: state.username.isEmpty ? nil : state.username, password: state.password.isEmpty ? nil : state.password))
+            case .mtp:
+                let parsedSecret = MTProxySecret.parse(state.secret)
+                if let parsedSecret = parsedSecret {
+                    return ProxyServerSettings(host: state.host, port: port, connection: .mtp(secret: parsedSecret.serialize()))
+                }
+        }
+    }
+    return nil
+}
+
+public func proxyServerSettingsController(context: AccountContext, currentSettings: ProxyServerSettings? = nil) -> ViewController {
+    let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+    return proxyServerSettingsController(sharedContext: context.sharedContext, context: context, presentationData: presentationData, updatedPresentationData: context.sharedContext.presentationData, accountManager: context.sharedContext.accountManager, network: context.account.network, currentSettings: currentSettings)
+}
+
+func proxyServerSettingsController(sharedContext: SharedAccountContext, context: AccountContext? = nil, presentationData: PresentationData, updatedPresentationData: Signal<PresentationData, NoError>, accountManager: AccountManager<TelegramAccountManagerTypes>, network: Network, currentSettings: ProxyServerSettings?) -> ViewController {
+    var currentMode: ProxyServerSettingsControllerMode = .socks5
+    var currentUsername: String?
+    var currentPassword: String?
+    var currentSecret: String?
+    var pasteboardSettings: ProxyServerSettings?
+    if let currentSettings = currentSettings {
+        switch currentSettings.connection {
+            case let .socks5(username, password):
+                currentUsername = username
+                currentPassword = password
+                currentMode = .socks5
+            case let .mtp(secret):
+                currentSecret = hexString(secret)
+                currentMode = .mtp
+        }
+    } else {
+        if let proxy = parseProxyUrl(sharedContext: sharedContext, url: UIPasteboard.general.string ?? "") {
+            if let secret = proxy.secret, let parsedSecret = MTProxySecret.parseData(secret) {
+                pasteboardSettings = ProxyServerSettings(host: proxy.host, port: proxy.port, connection: .mtp(secret: parsedSecret.serialize()))
+            } else {
+                pasteboardSettings = ProxyServerSettings(host: proxy.host, port: proxy.port, connection: .socks5(username: proxy.username, password: proxy.password))
+            }
+        }
+    }
+
+    let initialState = ProxyServerSettingsControllerState(mode: currentMode, host: currentSettings?.host ?? "", port: (currentSettings?.port).flatMap { "\($0)" } ?? "", username: currentUsername ?? "", password: currentPassword ?? "", secret: currentSecret ?? "")
+    let stateValue = Atomic(value: initialState)
+    let statePromise = ValuePromise(initialState, ignoreRepeated: true)
+    let updateState: ((ProxyServerSettingsControllerState) -> ProxyServerSettingsControllerState) -> Void = { f in
+        statePromise.set(stateValue.modify { f($0) })
+    }
+    
+    var presentControllerImpl: ((ViewController, Any?) -> Void)?
+    var dismissImpl: (() -> Void)?
+    
+    var shareImpl: (() -> Void)?
+    
+    let arguments = ProxyServerSettingsControllerArguments(updateState: { f in
+        updateState(f)
+    }, share: {
+        shareImpl?()
+    }, usePasteboardSettings: {
+        if let pasteboardSettings = pasteboardSettings {
+            updateState { state in
+                var state = state
+                state.host = pasteboardSettings.host
+                state.port = "\(pasteboardSettings.port)"
+                switch pasteboardSettings.connection {
+                    case let .socks5(username, password):
+                        state.mode = .socks5
+                        state.username = username ?? ""
+                        state.password = password ?? ""
+                    case let .mtp(secret):
+                        state.mode = .mtp
+                        state.secret = hexString(secret)
+                }
+                return state
+            }
+        }
+    })
+    
+    let signal = combineLatest(updatedPresentationData, statePromise.get())
+    |> deliverOnMainQueue
+    |> map { presentationData, state -> (ItemListControllerState, (ItemListNodeState, Any)) in
+        let leftNavigationButton = ItemListNavigationButton(content: .text(presentationData.strings.Common_Cancel), style: .regular, enabled: true, action: {
+            dismissImpl?()
+        })
+        let rightNavigationButton = ItemListNavigationButton(content: .text(presentationData.strings.Common_Done), style: .bold, enabled: state.isComplete, action: {
+            if let proxyServerSettings = proxyServerSettings(with: state) {
+                let _ = (updateProxySettingsInteractively(accountManager: accountManager, { settings in
+                    var settings = settings
+                    if let currentSettings = currentSettings {
+                        if let index = settings.servers.firstIndex(of: currentSettings) {
+                            settings.servers[index] = proxyServerSettings
+                            if settings.activeServer == currentSettings {
+                                settings.activeServer = proxyServerSettings
+                            }
+                        }
+                    } else {
+                        settings.servers.append(proxyServerSettings)
+                        if settings.servers.count == 1 {
+                            settings.activeServer = proxyServerSettings
+                        }
+                    }
+                    return settings
+                }) |> deliverOnMainQueue).start(completed: {
+                    dismissImpl?()
+                })
+            }
+        })
+        
+        let controllerState = ItemListControllerState(presentationData: ItemListPresentationData(presentationData), title: .text(presentationData.strings.SocksProxySetup_Title), leftNavigationButton: leftNavigationButton, rightNavigationButton: rightNavigationButton, backNavigationButton: ItemListBackButton(title: presentationData.strings.Common_Back), animateChanges: false)
+        let listState = ItemListNodeState(presentationData: ItemListPresentationData(presentationData), entries: proxyServerSettingsControllerEntries(presentationData: presentationData, state: state, pasteboardSettings: pasteboardSettings), style: .blocks, emptyStateItem: nil, animateChanges: false)
+        
+        return (controllerState, (listState, arguments))
+    }
+    
+    let controller = ItemListController(presentationData: ItemListPresentationData(presentationData), updatedPresentationData: updatedPresentationData |> map(ItemListPresentationData.init(_:)), state: signal, tabBarItem: nil)
+    controller.navigationPresentation = .modal
+    presentControllerImpl = { [weak controller] c, d in
+        controller?.present(c, in: .window(.root), with: d)
+    }
+    dismissImpl = { [weak controller] in
+        let _ = controller?.dismiss()
+    }
+    shareImpl = { [weak controller] in
+        let state = stateValue.with { $0 }
+        guard let server = proxyServerSettings(with: state) else {
+            return
+        }
+        
+        let link = shareLink(for: server)
+        controller?.view.endEditing(true)
+        
+        let controller = ShareProxyServerActionSheetController(presentationData: presentationData, updatedPresentationData: updatedPresentationData, link: link)
+        presentControllerImpl?(controller, nil)
+    }
+    
+    return controller
+}
+

submodules/SettingsUI/Sources/Data and Storage/ProxySettingsActionItem.swift

@@ -0,0 +1,288 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import TelegramPresentationData
+import ItemListUI
+import PresentationDataUtils
+
+enum ProxySettingsActionIcon {
+    case none
+    case add
+}
+
+final class ProxySettingsActionItem: ListViewItem, ItemListItem {
+    let presentationData: ItemListPresentationData
+    let systemStyle: ItemListSystemStyle
+    let title: String
+    let icon: ProxySettingsActionIcon
+    let editing: Bool
+    let sectionId: ItemListSectionId
+    let action: () -> Void
+    
+    init(presentationData: ItemListPresentationData, systemStyle: ItemListSystemStyle = .legacy, title: String, icon: ProxySettingsActionIcon = .none, sectionId: ItemListSectionId, editing: Bool, action: @escaping () -> Void) {
+        self.presentationData = presentationData
+        self.systemStyle = systemStyle
+        self.title = title
+        self.icon = icon
+        self.editing = editing
+        self.sectionId = sectionId
+        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 = ProxySettingsActionItemNode()
+            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? ProxySettingsActionItemNode {
+                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)
+                        })
+                    }
+                }
+            }
+        }
+    }
+    
+    var selectable: Bool = true
+    
+    func selected(listView: ListView){
+        listView.clearHighlightAnimated(true)
+        self.action()
+    }
+}
+
+private final class ProxySettingsActionItemNode: ListViewItemNode {
+    private let backgroundNode: ASDisplayNode
+    private let topStripeNode: ASDisplayNode
+    private let bottomStripeNode: ASDisplayNode
+    private let highlightedBackgroundNode: ASDisplayNode
+    private let maskNode: ASImageNode
+    
+    private let iconNode: ASImageNode
+    private let titleNode: TextNode
+    
+    private var item: ProxySettingsActionItem?
+    
+    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.iconNode = ASImageNode()
+        self.iconNode.isLayerBacked = true
+        self.iconNode.displayWithoutProcessing = true
+        self.iconNode.displaysAsynchronously = false
+        
+        self.titleNode = TextNode()
+        self.titleNode.isUserInteractionEnabled = false
+        self.titleNode.contentMode = .left
+        self.titleNode.contentsScale = UIScreen.main.scale
+        
+        self.highlightedBackgroundNode = ASDisplayNode()
+        self.highlightedBackgroundNode.isLayerBacked = true
+        
+        super.init(layerBacked: false, dynamicBounce: false)
+        
+        self.isAccessibilityElement = true
+        
+        self.addSubnode(self.iconNode)
+        self.addSubnode(self.titleNode)
+    }
+    
+    func asyncLayout() -> (_ item: ProxySettingsActionItem, _ params: ListViewItemLayoutParams, _ neighbors: ItemListNeighbors) -> (ListViewItemNodeLayout, (Bool) -> Void) {
+        let makeTitleLayout = TextNode.asyncLayout(self.titleNode)
+        
+        let currentItem = self.item
+        
+        return { item, params, neighbors in
+            var updatedTheme: PresentationTheme?
+            
+            let titleFont = Font.regular(item.presentationData.fontSize.itemListBaseFontSize)
+            
+            if currentItem?.presentationData.theme !== item.presentationData.theme {
+                updatedTheme = item.presentationData.theme
+            }
+            let leftInset: CGFloat = (item.icon != .none ? 50.0 : 16.0) + params.leftInset
+            
+            let editingOffset: CGFloat = (item.editing ? 38.0 : 0.0)
+            
+            let (titleLayout, titleApply) = makeTitleLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: item.title, font: titleFont, textColor: item.presentationData.theme.list.itemAccentColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width - leftInset - editingOffset, height: CGFloat.greatestFiniteMagnitude), alignment: .natural, cutout: nil, insets: UIEdgeInsets()))
+            
+            let separatorHeight = UIScreenPixel
+            let separatorRightInset: CGFloat = item.systemStyle == .glass ? 16.0 : 0.0
+            
+            let verticalInset: CGFloat
+            switch item.systemStyle {
+            case .glass:
+                verticalInset = 15.0
+            case .legacy:
+                verticalInset = 11.0
+            }
+            
+            let insets = itemListNeighborsGroupedInsets(neighbors, params)
+            let contentSize = CGSize(width: params.width, height: verticalInset * 2.0 + titleLayout.size.height)
+            
+            let layout = ListViewItemNodeLayout(contentSize: contentSize, insets: insets)
+            let layoutSize = layout.size
+            
+            let icon = item.icon == .add ? PresentationResourcesItemList.plusIconImage(item.presentationData.theme) : nil
+            
+            return (layout, { [weak self] animated in
+                if let strongSelf = self {
+                    strongSelf.item = item
+                    
+                    strongSelf.accessibilityLabel = item.title
+                    
+                    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 _ = titleApply()
+                    
+                    let transition: ContainedViewLayoutTransition
+                    if animated {
+                        transition = ContainedViewLayoutTransition.animated(duration: 0.4, curve: .spring)
+                    } else {
+                        transition = .immediate
+                    }
+                    
+                    strongSelf.iconNode.image = icon
+                    if let image = icon {
+                        transition.updateFrame(node: strongSelf.iconNode, frame: CGRect(origin: CGPoint(x: params.leftInset + editingOffset + floor((leftInset - params.leftInset - image.size.width) / 2.0), y: floor((contentSize.height - image.size.height) / 2.0)), size: image.size))
+                    }
+                    
+                    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.insertSubnode(strongSelf.maskNode, at: 3)
+                    }
+                    
+                    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.maskNode.frame = strongSelf.backgroundNode.frame.insetBy(dx: params.leftInset, dy: 0.0)
+                    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.titleNode, frame: CGRect(origin: CGPoint(x: leftInset + editingOffset, y: floorToScreenPixels((contentSize.height - titleLayout.size.height) / 2.0) + 1.0), size: titleLayout.size))
+                    
+                    strongSelf.highlightedBackgroundNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -UIScreenPixel), size: CGSize(width: params.width, height: contentSize.height + UIScreenPixel))
+                }
+            })
+        }
+    }
+    
+    override func setHighlighted(_ highlighted: Bool, at point: CGPoint, animated: Bool) {
+        super.setHighlighted(highlighted, at: point, animated: animated)
+        
+        if highlighted {
+            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)
+    }
+}

submodules/SettingsUI/Sources/Data and Storage/ProxySettingsServerItem.swift

@@ -0,0 +1,560 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import TelegramCore
+import TelegramPresentationData
+import ItemListUI
+import PresentationDataUtils
+import ActivityIndicator
+import UrlEscaping
+
+private let activitySize = CGSize(width: 24.0, height: 24.0)
+
+struct ProxySettingsServerItemEditing: Equatable {
+    let editable: Bool
+    let editing: Bool
+    let revealed: Bool
+}
+
+final class ProxySettingsServerItem: ListViewItem, ItemListItem {
+    let theme: PresentationTheme
+    let strings: PresentationStrings
+    let systemStyle: ItemListSystemStyle
+    let server: ProxyServerSettings
+    let activity: Bool
+    let active: Bool
+    let color: ItemListCheckboxItemColor
+    let label: String
+    let labelAccent: Bool
+    let editing: ProxySettingsServerItemEditing
+    let sectionId: ItemListSectionId
+    let action: () -> Void
+    let infoAction: () -> Void
+    let setServerWithRevealedOptions: (ProxyServerSettings?, ProxyServerSettings?) -> Void
+    let removeServer: (ProxyServerSettings) -> Void
+    
+    init(theme: PresentationTheme, strings: PresentationStrings, systemStyle: ItemListSystemStyle = .legacy, server: ProxyServerSettings, activity: Bool, active: Bool, color: ItemListCheckboxItemColor, label: String, labelAccent: Bool, editing: ProxySettingsServerItemEditing, sectionId: ItemListSectionId, action: @escaping () -> Void, infoAction: @escaping () -> Void, setServerWithRevealedOptions: @escaping (ProxyServerSettings?, ProxyServerSettings?) -> Void, removeServer: @escaping (ProxyServerSettings) -> Void) {
+        self.theme = theme
+        self.strings = strings
+        self.systemStyle = systemStyle
+        self.server = server
+        self.activity = activity
+        self.active = active
+        self.color = color
+        self.label = label
+        self.labelAccent = labelAccent
+        self.editing = editing
+        self.sectionId = sectionId
+        self.action = action
+        self.infoAction = infoAction
+        self.setServerWithRevealedOptions = setServerWithRevealedOptions
+        self.removeServer = removeServer
+    }
+    
+    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 = ProxySettingsServerItemNode()
+            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? ProxySettingsServerItemNode {
+                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)
+                        })
+                    }
+                }
+            }
+        }
+    }
+    
+    var selectable: Bool = true
+    
+    func selected(listView: ListView){
+        listView.clearHighlightAnimated(true)
+        self.action()
+    }
+}
+
+private let titleFont = Font.regular(17.0)
+private let statusFont = Font.regular(14.0)
+
+private final class ProxySettingsServerItemNode: ItemListRevealOptionsItemNode {
+    private let backgroundNode: ASDisplayNode
+    private let topStripeNode: ASDisplayNode
+    private let bottomStripeNode: ASDisplayNode
+    private let highlightedBackgroundNode: ASDisplayNode
+    private let maskNode: ASImageNode
+    
+    private let titleNode: TextNode
+    private let infoIconNode: ASImageNode
+    private let infoButtonNode: HighlightableButtonNode
+    private let statusNode: TextNode
+    private let checkNode: ASImageNode
+    private let activityNode: ActivityIndicator
+    
+    private let activateArea: AccessibilityAreaNode
+    
+    private var editableControlNode: ItemListEditableControlNode?
+    private var reorderControlNode: ItemListEditableReorderControlNode?
+    
+    private var item: ProxySettingsServerItem?
+    private var layoutParams: ListViewItemLayoutParams?
+    
+    override var canBeSelected: Bool {
+        if self.editableControlNode != nil {
+            return false
+        }
+        return true
+    }
+    
+    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.infoIconNode = ASImageNode()
+        self.infoIconNode.isLayerBacked = true
+        self.infoIconNode.displayWithoutProcessing = true
+        self.infoIconNode.displaysAsynchronously = false
+        
+        self.checkNode = ASImageNode()
+        self.checkNode.isLayerBacked = true
+        self.checkNode.displayWithoutProcessing = true
+        self.checkNode.displaysAsynchronously = false
+        
+        self.titleNode = TextNode()
+        self.titleNode.isUserInteractionEnabled = false
+        self.titleNode.contentMode = .left
+        self.titleNode.contentsScale = UIScreen.main.scale
+        
+        self.statusNode = TextNode()
+        self.statusNode.isUserInteractionEnabled = false
+        self.statusNode.contentMode = .left
+        self.statusNode.contentsScale = UIScreen.main.scale
+        
+        self.activityNode = ActivityIndicator(type: .custom(.blue, activitySize.width, 2.0, false))
+        self.activityNode.isHidden = true
+        
+        self.activateArea = AccessibilityAreaNode()
+        
+        self.infoButtonNode = HighlightableButtonNode()
+        
+        self.highlightedBackgroundNode = ASDisplayNode()
+        self.highlightedBackgroundNode.isLayerBacked = true
+        
+        super.init(layerBacked: false, dynamicBounce: false, rotated: false, seeThrough: false)
+        
+        self.addSubnode(self.titleNode)
+        self.addSubnode(self.statusNode)
+        self.addSubnode(self.checkNode)
+        self.addSubnode(self.infoIconNode)
+        self.addSubnode(self.activityNode)
+        self.addSubnode(self.infoButtonNode)
+        self.addSubnode(self.activateArea)
+        
+        self.infoButtonNode.highligthedChanged = { [weak self] highlighted in
+            if let strongSelf = self {
+                if highlighted {
+                    strongSelf.infoIconNode.layer.removeAnimation(forKey: "opacity")
+                    strongSelf.infoIconNode.alpha = 0.4
+                } else {
+                    strongSelf.infoIconNode.alpha = 1.0
+                    strongSelf.infoIconNode.layer.animateAlpha(from: 0.4, to: 1.0, duration: 0.2)
+                }
+            }
+        }
+        self.infoButtonNode.addTarget(self, action: #selector(self.infoButtonPressed), forControlEvents: .touchUpInside)
+        
+        self.activateArea.activate = { [weak self] in
+            self?.item?.action()
+            return true
+        }
+    }
+    
+    func asyncLayout() -> (_ item: ProxySettingsServerItem, _ params: ListViewItemLayoutParams, _ neighbors: ItemListNeighbors) -> (ListViewItemNodeLayout, (Bool) -> Void) {
+        let makeTitleLayout = TextNode.asyncLayout(self.titleNode)
+        let makeStatusLayout = TextNode.asyncLayout(self.statusNode)
+        let editableControlLayout = ItemListEditableControlNode.asyncLayout(self.editableControlNode)
+        let reorderControlLayout = ItemListEditableReorderControlNode.asyncLayout(self.reorderControlNode)
+        
+        let currentItem = self.item
+        
+        return { item, params, neighbors in
+            var updateInfoIconImage: UIImage?
+            var updateCheckImage: UIImage?
+            var updatedTheme: PresentationTheme?
+            
+            if currentItem?.theme !== item.theme {
+                updatedTheme = item.theme
+                updateInfoIconImage = PresentationResourcesCallList.infoButton(item.theme)
+            }
+            
+            if currentItem?.theme !== item.theme || currentItem?.color != item.color {
+                switch item.color {
+                    case .accent:
+                        updateCheckImage = PresentationResourcesItemList.checkIconImage(item.theme)
+                    case .secondary:
+                        updateCheckImage = PresentationResourcesItemList.secondaryCheckIconImage(item.theme)
+                }
+            }
+            
+            let peerRevealOptions: [ItemListRevealOption]
+            if item.editing.editable {
+                peerRevealOptions = [ItemListRevealOption(key: 0, title: item.strings.Common_Delete, icon: .none, color: item.theme.list.itemDisclosureActions.destructive.fillColor, textColor: item.theme.list.itemDisclosureActions.destructive.foregroundColor)]
+            } else {
+                peerRevealOptions = []
+            }
+            
+            let titleAttributedString = NSMutableAttributedString()
+            titleAttributedString.append(NSAttributedString(string: urlEncodedStringFromString(item.server.host), font: titleFont, textColor: item.theme.list.itemPrimaryTextColor))
+            titleAttributedString.append(NSAttributedString(string: ":\(item.server.port)", font: titleFont, textColor: item.theme.list.itemSecondaryTextColor))
+            let statusAttributedString = NSAttributedString(string: item.label, font: statusFont, textColor: item.labelAccent ? item.theme.list.itemAccentColor : item.theme.list.itemSecondaryTextColor)
+            
+            var editableControlSizeAndApply: (CGFloat, (CGFloat) -> ItemListEditableControlNode)?
+            var reorderControlSizeAndApply: (CGFloat, (CGFloat, Bool, ContainedViewLayoutTransition) -> ItemListEditableReorderControlNode)?
+            
+            let editingOffset: CGFloat
+            var reorderInset: CGFloat = 0.0
+            
+            if item.editing.editing {
+                let sizeAndApply = editableControlLayout(item.theme, false)
+                editableControlSizeAndApply = sizeAndApply
+                editingOffset = sizeAndApply.0
+                
+                let reorderSizeAndApply = reorderControlLayout(item.theme)
+                reorderControlSizeAndApply = reorderSizeAndApply
+                reorderInset = reorderSizeAndApply.0
+            } else {
+                editingOffset = 0.0
+            }
+            
+            let leftInset: CGFloat = 50.0 + params.leftInset
+            let rightInset: CGFloat = params.rightInset + max(reorderInset, 55.0)
+            
+            let (titleLayout, titleApply) = makeTitleLayout(TextNodeLayoutArguments(attributedString: titleAttributedString, backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .middle, constrainedSize: CGSize(width: params.width - leftInset - 12.0 - editingOffset - rightInset, height: CGFloat.greatestFiniteMagnitude), alignment: .natural, cutout: nil, insets: UIEdgeInsets()))
+            let (statusLayout, statusApply) = makeStatusLayout(TextNodeLayoutArguments(attributedString: statusAttributedString, 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: 64.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
+            
+            return (layout, { [weak self] animated in
+                if let strongSelf = self {
+                    strongSelf.item = item
+                    strongSelf.layoutParams = params
+                    
+                    strongSelf.infoButtonNode.accessibilityLabel = item.strings.Conversation_Info
+                    strongSelf.activateArea.accessibilityLabel = "\(titleAttributedString.string)\n\(statusAttributedString.string)"
+                    if item.active {
+                        strongSelf.activateArea.accessibilityValue = item.strings.ProxyServer_VoiceOver_Active
+                    } else {
+                        strongSelf.activateArea.accessibilityValue = ""
+                    }
+                    
+                    if let updateInfoIconImage = updateInfoIconImage {
+                        strongSelf.infoIconNode.image = updateInfoIconImage
+                    }
+                    if let updateCheckImage = updateCheckImage {
+                        strongSelf.checkNode.image = updateCheckImage
+                    }
+                    
+                    if let _ = updatedTheme {
+                        strongSelf.topStripeNode.backgroundColor = item.theme.list.itemBlocksSeparatorColor
+                        strongSelf.bottomStripeNode.backgroundColor = item.theme.list.itemBlocksSeparatorColor
+                        strongSelf.backgroundNode.backgroundColor = item.theme.list.itemBlocksBackgroundColor
+                        strongSelf.highlightedBackgroundNode.backgroundColor = item.theme.list.itemHighlightedBackgroundColor
+                        
+                        strongSelf.activityNode.type = .custom(item.theme.list.itemAccentColor, activitySize.width, 2.0, false)
+                    }
+                    
+                    let revealOffset = strongSelf.revealOffset
+                    
+                    let transition: ContainedViewLayoutTransition
+                    if animated {
+                        transition = ContainedViewLayoutTransition.animated(duration: 0.4, curve: .spring)
+                    } else {
+                        transition = .immediate
+                    }
+                    
+                    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.titleNode)
+                            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.editing.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()
+                        })
+                    }
+                    
+                    if let reorderControlSizeAndApply = reorderControlSizeAndApply {
+                        if strongSelf.reorderControlNode == nil {
+                            let reorderControlNode = reorderControlSizeAndApply.1(layout.contentSize.height, false, .immediate)
+                            strongSelf.reorderControlNode = reorderControlNode
+                            strongSelf.addSubnode(reorderControlNode)
+                            reorderControlNode.alpha = 0.0
+                            transition.updateAlpha(node: reorderControlNode, alpha: 1.0)
+                        }
+                        let reorderControlFrame = CGRect(origin: CGPoint(x: params.width + revealOffset - params.rightInset - reorderControlSizeAndApply.0, y: 0.0), size: CGSize(width: reorderControlSizeAndApply.0, height: layout.contentSize.height))
+                        strongSelf.reorderControlNode?.frame = reorderControlFrame
+                    } else if let reorderControlNode = strongSelf.reorderControlNode {
+                        strongSelf.reorderControlNode = nil
+                        transition.updateAlpha(node: reorderControlNode, alpha: 0.0, completion: { [weak reorderControlNode] _ in
+                            reorderControlNode?.removeFromSupernode()
+                        })
+                    }
+                    
+                    let _ = titleApply()
+                    let _ = statusApply()
+                    
+                    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.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.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.titleNode, frame: CGRect(origin: CGPoint(x: leftInset + revealOffset + editingOffset, y: 12.0 + verticalInset), size: titleLayout.size))
+                    transition.updateFrame(node: strongSelf.statusNode, frame: CGRect(origin: CGPoint(x: leftInset + revealOffset + editingOffset, y: 37.0 + verticalInset), size: statusLayout.size))
+                    
+                    strongSelf.activateArea.frame = CGRect(origin: CGPoint(x: leftInset + revealOffset + editingOffset, y: 0.0), size: CGSize(width: params.width - params.rightInset - 56.0 - (leftInset + revealOffset + editingOffset), height: layout.contentSize.height))
+                    
+                    transition.updateAlpha(node: strongSelf.infoIconNode, alpha: item.editing.editing ? 0.0 : 1.0)
+                    
+                    if let checkImage = strongSelf.checkNode.image {
+                        transition.updateFrame(node: strongSelf.checkNode, frame: CGRect(origin: CGPoint(x: params.leftInset + revealOffset + editingOffset + floor((50.0 - checkImage.size.width) / 2.0), y: floor((layout.contentSize.height - checkImage.size.height) / 2.0)), size: checkImage.size))
+                    }
+                    transition.updateFrame(node: strongSelf.activityNode, frame: CGRect(origin: CGPoint(x: params.leftInset + revealOffset + editingOffset + floor((50.0 - activitySize.width) / 2.0), y: floor((layout.contentSize.height - activitySize.height) / 2.0)), size: activitySize))
+                    strongSelf.checkNode.isHidden = !item.active || item.activity
+                    strongSelf.activityNode.isHidden = !item.activity
+                    
+                    if let infoImage = strongSelf.infoIconNode.image {
+                        transition.updateFrame(node: strongSelf.infoIconNode, frame: CGRect(origin: CGPoint(x: revealOffset + params.width - params.rightInset - 55.0 + floor((55.0 - infoImage.size.width) / 2.0), y: floor((layout.contentSize.height - infoImage.size.height) / 2.0)), size: infoImage.size))
+                    }
+                    
+                    strongSelf.infoButtonNode.isUserInteractionEnabled = revealOffset.isZero && !item.editing.editing
+                    strongSelf.infoButtonNode.frame = CGRect(origin: CGPoint(x: params.width - params.rightInset - 55.0, y: 0.0), size: CGSize(width: 55.0, height: layout.contentSize.height))
+                    
+                    strongSelf.highlightedBackgroundNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -UIScreenPixel), size: CGSize(width: params.width, height: contentSize.height + UIScreenPixel + UIScreenPixel))
+                    
+                    strongSelf.updateLayout(size: layout.contentSize, leftInset: params.leftInset, rightInset: params.rightInset)
+                    
+                    strongSelf.setRevealOptions((left: [], right: peerRevealOptions))
+                    strongSelf.setRevealOptionsOpened(item.editing.revealed, animated: animated)
+                }
+            })
+        }
+    }
+    
+    override func setHighlighted(_ highlighted: Bool, at point: CGPoint, animated: Bool) {
+        super.setHighlighted(highlighted, at: point, animated: animated)
+        
+        if highlighted {
+            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 else {
+            return
+        }
+        
+        let leftInset: CGFloat = 50.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.titleNode, frame: CGRect(origin: CGPoint(x: leftInset + offset + editingOffset, y: self.titleNode.frame.minY), size: self.titleNode.bounds.size))
+        transition.updateFrame(node: self.statusNode, frame: CGRect(origin: CGPoint(x: leftInset + offset + editingOffset, y: self.statusNode.frame.minY), size: self.statusNode.bounds.size))
+        
+        var checkFrame = self.checkNode.frame
+        checkFrame.origin.x = params.leftInset + offset + editingOffset + floor((50.0 - checkFrame.width) / 2.0)
+        transition.updateFrame(node: self.checkNode, frame: checkFrame)
+        
+        var activityFrame = self.activityNode.frame
+        activityFrame.origin.x = params.leftInset + offset + editingOffset + floor((50.0 - activityFrame.width) / 2.0)
+        transition.updateFrame(node: self.activityNode, frame: activityFrame)
+        
+        var infoIconFrame = self.infoIconNode.frame
+        infoIconFrame.origin.x = offset + params.width - params.rightInset - 55.0 + floor((55.0 - infoIconFrame.width) / 2.0)
+        transition.updateFrame(node: self.infoIconNode, frame: infoIconFrame)
+        
+        self.infoButtonNode.isUserInteractionEnabled = offset.isZero
+    }
+    
+    override func revealOptionsInteractivelyOpened() {
+        if let item = self.item {
+            item.setServerWithRevealedOptions(item.server, nil)
+        }
+    }
+    
+    override func revealOptionsInteractivelyClosed() {
+        if let item = self.item {
+            item.setServerWithRevealedOptions(nil, item.server)
+        }
+    }
+    
+    override func revealOptionSelected(_ option: ItemListRevealOption, animated: Bool) {
+        self.setRevealOptionsOpened(false, animated: true)
+        self.revealOptionsInteractivelyClosed()
+        
+         if let item = self.item {
+            item.removeServer(item.server)
+        }
+    }
+    
+    override func isReorderable(at point: CGPoint) -> Bool {
+        if let reorderControlNode = self.reorderControlNode, reorderControlNode.frame.contains(point), !self.isDisplayingRevealedOptions {
+            return true
+        }
+        return false
+    }
+    
+    @objc private func infoButtonPressed() {
+        self.item?.infoAction()
+    }
+}

submodules/SettingsUI/Sources/Data and Storage/SaveIncomingMediaController.swift

@@ -0,0 +1,748 @@
+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 ItemListAvatarAndNameInfoItem
+import ItemListPeerItem
+
+private enum MediaType {
+    case photo
+    case video
+}
+
+private final class SaveIncomingMediaControllerArguments {
+    let context: AccountContext
+    let toggle: (MediaType) -> Void
+    let updateMaximumVideoSize: (Int64) -> Void
+    let openAddException: () -> Void
+    let openPeerMenu: (EnginePeer) -> Void
+    let setPeerIdWithRevealedOptions: (EnginePeer.Id?, EnginePeer.Id?) -> Void
+    let deletePeer: (EnginePeer.Id) -> Void
+    let deleteAllExceptions: () -> Void
+    
+    init(context: AccountContext, toggle: @escaping (MediaType) -> Void, updateMaximumVideoSize: @escaping (Int64) -> Void, openAddException: @escaping () -> Void, openPeerMenu: @escaping (EnginePeer) -> Void, setPeerIdWithRevealedOptions: @escaping (EnginePeer.Id?, EnginePeer.Id?) -> Void, deletePeer: @escaping (EnginePeer.Id) -> Void, deleteAllExceptions: @escaping () -> Void) {
+        self.context = context
+        self.toggle = toggle
+        self.updateMaximumVideoSize = updateMaximumVideoSize
+        self.openAddException = openAddException
+        self.openPeerMenu = openPeerMenu
+        self.setPeerIdWithRevealedOptions = setPeerIdWithRevealedOptions
+        self.deletePeer = deletePeer
+        self.deleteAllExceptions = deleteAllExceptions
+    }
+}
+
+enum SaveIncomingMediaSection: ItemListSectionId {
+    case peer
+    case mediaTypes
+    case videoSize
+    case exceptions
+    case deleteAllExceptions
+}
+
+private enum SaveIncomingMediaEntry: ItemListNodeEntry {
+    enum StableId: Hashable {
+        case peer
+        
+        case typesHeader
+        case typePhotos
+        case typeVideos
+        case typesInfo
+        
+        case videoSizeHeader
+        case videoSize
+        case videoInfo
+        
+        case exceptionsHeader
+        case addException
+        case exceptionItem(EnginePeer.Id)
+        
+        case deleteAllExceptions
+    }
+    
+    case peer(peer: EnginePeer, presence: EnginePeer.Presence?)
+    
+    case typesHeader(String)
+    case typePhotos(String, Bool)
+    case typeVideos(String, Bool)
+    case typesInfo(String)
+    
+    case videoSizeHeader(String)
+    case videoSize(decimalSeparator: String, text: String, value: Int64)
+    case videoInfo(String)
+    
+    case exceptionsHeader(String)
+    case addException(String)
+    case exceptionItem(index: Int, peer: EnginePeer, label: String)
+    
+    case deleteAllExceptions(String)
+    
+    var section: ItemListSectionId {
+        switch self {
+        case .peer:
+            return SaveIncomingMediaSection.peer.rawValue
+        case .typesHeader, .typePhotos, .typeVideos, .typesInfo:
+            return SaveIncomingMediaSection.mediaTypes.rawValue
+        case .videoSizeHeader, .videoSize, .videoInfo:
+            return SaveIncomingMediaSection.videoSize.rawValue
+        case .exceptionsHeader, .addException, .exceptionItem:
+            return SaveIncomingMediaSection.exceptions.rawValue
+        case .deleteAllExceptions:
+            return SaveIncomingMediaSection.deleteAllExceptions.rawValue
+        }
+    }
+    
+    var stableId: StableId {
+        switch self {
+        case .peer:
+            return .peer
+        case .typesHeader:
+            return .typesHeader
+        case .typePhotos:
+            return .typePhotos
+        case .typeVideos:
+            return .typeVideos
+        case .typesInfo:
+            return .typesInfo
+        case .videoSizeHeader:
+            return .videoSizeHeader
+        case .videoSize:
+            return .videoSize
+        case .videoInfo:
+            return .videoInfo
+        case .exceptionsHeader:
+            return .exceptionsHeader
+        case .addException:
+            return .addException
+        case let .exceptionItem(_, peer, _):
+            return .exceptionItem(peer.id)
+        case .deleteAllExceptions:
+            return .deleteAllExceptions
+        }
+    }
+    
+    var sortIndex: Int {
+        switch self {
+        case .peer:
+            return 0
+        case .typesHeader:
+            return 1
+        case .typePhotos:
+            return 2
+        case .typeVideos:
+            return 3
+        case .typesInfo:
+            return 4
+        case .videoSizeHeader:
+            return 5
+        case .videoSize:
+            return 6
+        case .videoInfo:
+            return 7
+        case .exceptionsHeader:
+            return 8
+        case .addException:
+            return 9
+        case let .exceptionItem(index, _, _):
+            return 100 + index
+        case .deleteAllExceptions:
+            return 100000
+        }
+    }
+    
+    static func <(lhs: SaveIncomingMediaEntry, rhs: SaveIncomingMediaEntry) -> Bool {
+        return lhs.sortIndex < rhs.sortIndex
+    }
+    
+    func item(presentationData: ItemListPresentationData, arguments: Any) -> ListViewItem {
+        let arguments = arguments as! SaveIncomingMediaControllerArguments
+        switch self {
+        case let .peer(peer, presence):
+            return ItemListAvatarAndNameInfoItem(
+                itemContext: .accountContext(arguments.context),
+                presentationData: presentationData,
+                systemStyle: .glass,
+                dateTimeFormat: PresentationDateTimeFormat(),
+                mode: .generic,
+                peer: peer,
+                presence: presence,
+                memberCount: nil,
+                state: ItemListAvatarAndNameInfoItemState(),
+                sectionId: self.section,
+                style: .blocks(withTopInset: true, withExtendedBottomInset: false),
+                editingNameUpdated: { _ in
+                },
+                avatarTapped: {
+                }
+            )
+        case let .typesHeader(text):
+            return ItemListSectionHeaderItem(presentationData: presentationData, text: text, sectionId: self.section)
+        case let .typePhotos(title, value):
+            return ItemListSwitchItem(presentationData: presentationData, systemStyle: .glass, icon: UIImage(bundleImageName: "Settings/Menu/DataPhotos"), title: title, value: value, sectionId: self.section, style: .blocks, updated: { _ in
+                arguments.toggle(.photo)
+            })
+        case let .typeVideos(title, value):
+            return ItemListSwitchItem(presentationData: presentationData, systemStyle: .glass, icon: UIImage(bundleImageName: "Settings/Menu/DataVideo"), title: title, value: value, sectionId: self.section, style: .blocks, updated: { _ in
+                arguments.toggle(.video)
+            })
+        case let .typesInfo(text):
+            return ItemListTextItem(presentationData: presentationData, text: .markdown(text), sectionId: self.section)
+        case let .videoSizeHeader(title):
+            return ItemListSectionHeaderItem(presentationData: presentationData, text: title, sectionId: self.section)
+        case let .videoSize(decimalSeparator, text, size):
+            return AutodownloadSizeLimitItem(theme: presentationData.theme, strings: presentationData.strings, systemStyle: .glass, decimalSeparator: decimalSeparator, text: text, value: size, range: nil/*2 * 1024 * 1024 ..< (4 * 1024 * 1024 * 1024)*/, sectionId: self.section, updated: { value in
+                arguments.updateMaximumVideoSize(value)
+            })
+        case let .videoInfo(text):
+            return ItemListTextItem(presentationData: presentationData, text: .markdown(text), sectionId: self.section)
+        case let .exceptionsHeader(title):
+            return ItemListSectionHeaderItem(presentationData: presentationData, text: title, sectionId: self.section)
+        case let .addException(title):
+            let icon: UIImage? = PresentationResourcesItemList.createGroupIcon(presentationData.theme)
+            return ItemListPeerActionItem(presentationData: presentationData, systemStyle: .glass, icon: icon, title: title, alwaysPlain: false, sectionId: self.section, height: .generic, editing: false, action: {
+                arguments.openAddException()
+            })
+        case let .exceptionItem(_, peer, label):
+            return ItemListPeerItem(
+                presentationData: presentationData,
+                systemStyle: .glass,
+                dateTimeFormat: PresentationDateTimeFormat(),
+                nameDisplayOrder: .firstLast,
+                context: arguments.context,
+                peer: peer,
+                height: .generic,
+                aliasHandling: .threatSelfAsSaved,
+                nameColor: .primary,
+                presence: nil,
+                text: .text(label, .secondary),
+                label: .none,
+                editing: ItemListPeerItemEditing(editable: true, editing: false, revealed: false),
+                revealOptions: ItemListPeerItemRevealOptions(options: [ItemListPeerItemRevealOption(type: .destructive, title: presentationData.strings.Common_Delete, action: {
+                    arguments.deletePeer(peer.id)
+                })]),
+                switchValue: nil,
+                enabled: true,
+                selectable: true,
+                sectionId: self.section,
+                action: {
+                    arguments.openPeerMenu(peer)
+                },
+                setPeerIdWithRevealedOptions: { lhs, rhs in
+                    arguments.setPeerIdWithRevealedOptions(lhs, rhs)
+                },
+                removePeer: { id in
+                    arguments.deletePeer(id)
+                }
+            )
+            /*return ItemListDisclosureItem(presentationData: presentationData, icon: nil, context: arguments.context, iconPeer: peer, title: peer.displayTitle(strings: presentationData.strings, displayOrder: .firstLast), enabled: true, titleFont: .bold, label: label, labelStyle: .detailText, additionalDetailLabel: nil, sectionId: self.section, style: .blocks, disclosureStyle: .none, action: {
+                arguments.openPeerMenu(peer)
+            }, tag: nil)*/
+        case let .deleteAllExceptions(title):
+            return ItemListActionItem(presentationData: presentationData, systemStyle: .glass, title: title, kind: .destructive, alignment: .center, sectionId: self.section, style: .blocks, action: {
+                arguments.deleteAllExceptions()
+            })
+        }
+    }
+}
+
+private func saveIncomingMediaControllerEntries(presentationData: PresentationData, scope: SaveIncomingMediaScope, state: SaveIncomingMediaControllerState, peer: EnginePeer?, peerPresence: EnginePeer.Presence?, configuration: MediaAutoSaveConfiguration, exceptions: [MediaAutoSaveSettings.ExceptionItem], autosaveExceptionPeers: [EnginePeer.Id: EnginePeer?]) -> [SaveIncomingMediaEntry] {
+    var entries: [SaveIncomingMediaEntry] = []
+    
+    if case .peer = scope, let peer {
+        entries.append(.peer(peer: peer, presence: peerPresence))
+    }
+    
+    entries.append(.typesHeader(presentationData.strings.Autosave_TypesSection))
+    
+    entries.append(.typePhotos(presentationData.strings.Autosave_TypePhoto, configuration.photo))
+    entries.append(.typeVideos(presentationData.strings.Autosave_TypeVideo, configuration.video))
+    entries.append(.typesInfo(presentationData.strings.Autosave_TypesInfo))
+    
+    if configuration.video {
+        let sizeText: String
+        if configuration.maximumVideoSize == Int64.max {
+            sizeText = autodownloadDataSizeString(1536 * 1024 * 1024, decimalSeparator: presentationData.dateTimeFormat.decimalSeparator)
+        } else {
+            sizeText = autodownloadDataSizeString(configuration.maximumVideoSize, decimalSeparator: presentationData.dateTimeFormat.decimalSeparator)
+        }
+        
+        let text = presentationData.strings.AutoDownloadSettings_UpTo(sizeText).string
+        
+        entries.append(.videoSizeHeader(presentationData.strings.Autosave_VideoSizeSection))
+        entries.append(.videoSize(decimalSeparator: presentationData.dateTimeFormat.decimalSeparator, text: text, value: configuration.maximumVideoSize))
+        entries.append(.videoInfo(presentationData.strings.Autosave_VideoInfo(sizeText).string))
+    }
+    
+    if case let .peerType(peerType) = scope {
+        var filteredExceptions: [(EnginePeer, MediaAutoSaveConfiguration)] = []
+        for exception in exceptions {
+            guard let maybeExceptionPeer = autosaveExceptionPeers[exception.id], let exceptionPeer = maybeExceptionPeer else {
+                continue
+            }
+            let peerTypeValue: AutomaticSaveIncomingPeerType
+            switch exceptionPeer {
+            case .user, .secretChat:
+                peerTypeValue = .privateChats
+            case .legacyGroup:
+                peerTypeValue = .groups
+            case let .channel(channel):
+                if case .broadcast = channel.info {
+                    peerTypeValue = .channels
+                } else {
+                    peerTypeValue = .groups
+                }
+            }
+            
+            if peerTypeValue == peerType {
+                filteredExceptions.append((exceptionPeer, exception.configuration))
+            }
+        }
+        
+        if filteredExceptions.isEmpty {
+            entries.append(.exceptionsHeader(presentationData.strings.Autosave_ExceptionsSection))
+        } else {
+            entries.append(.exceptionsHeader(presentationData.strings.Notifications_CategoryExceptions(Int32(filteredExceptions.count)).uppercased()))
+        }
+        
+        entries.append(.addException(presentationData.strings.Autosave_AddException))
+        
+        var index = 0
+        for (exceptionPeer, exceptionConfiguration) in filteredExceptions {
+            var label = ""
+            if exceptionConfiguration.photo {
+                if !label.isEmpty {
+                    label.append(", ")
+                }
+                label.append(presentationData.strings.Settings_AutosaveMediaPhoto)
+            } else {
+                if !label.isEmpty {
+                    label.append(", ")
+                }
+                label.append(presentationData.strings.Settings_AutosaveMediaNoPhoto)
+            }
+            if exceptionConfiguration.video {
+                if !label.isEmpty {
+                    label.append(", ")
+                }
+                label.append(presentationData.strings.Settings_AutosaveMediaVideo(dataSizeString(Int(exceptionConfiguration.maximumVideoSize), formatting: DataSizeStringFormatting(presentationData: presentationData))).string)
+            } else {
+                if !label.isEmpty {
+                    label.append(", ")
+                }
+                label.append(presentationData.strings.Settings_AutosaveMediaNoVideo)
+            }
+            
+            entries.append(.exceptionItem(index: index, peer: exceptionPeer, label: label))
+            index += 1
+        }
+        
+        if !filteredExceptions.isEmpty {
+            entries.append(.deleteAllExceptions(presentationData.strings.Autosave_DeleteAllExceptions))
+        }
+    }
+    
+    return entries
+}
+
+enum SaveIncomingMediaScope {
+    case peer(EnginePeer.Id)
+    case addPeer(id: EnginePeer.Id, completion: (MediaAutoSaveConfiguration) -> Void)
+    case peerType(AutomaticSaveIncomingPeerType)
+}
+
+private struct SaveIncomingMediaControllerState: Equatable {
+    var pendingConfiguration: MediaAutoSaveConfiguration = .default
+    var peerIdWithOptions: EnginePeer.Id?
+}
+
+func saveIncomingMediaController(context: AccountContext, scope: SaveIncomingMediaScope) -> ViewController {
+    let stateValue = Atomic(value: SaveIncomingMediaControllerState())
+    let statePromise = ValuePromise<SaveIncomingMediaControllerState>(stateValue.with { $0 })
+    let updateState: ((SaveIncomingMediaControllerState) -> SaveIncomingMediaControllerState) -> Void = { f in
+        var changed = false
+        let value = stateValue.modify { current in
+            let updated = f(current)
+            if updated != current {
+                changed = true
+            }
+            return updated
+        }
+        if changed {
+            statePromise.set(value)
+        }
+    }
+    
+    var pushController: ((ViewController) -> Void)?
+    var presentControllerImpl: ((ViewController) -> Void)?
+    var dismiss: (() -> Void)?
+    
+    let arguments = SaveIncomingMediaControllerArguments(
+        context: context,
+        toggle: { type in
+            if case .addPeer = scope {
+                updateState { state in
+                    var state = state
+                    
+                    switch type {
+                    case .photo:
+                        state.pendingConfiguration.photo = !state.pendingConfiguration.photo
+                    case .video:
+                        state.pendingConfiguration.video = !state.pendingConfiguration.video
+                    }
+                    
+                    return state
+                }
+            } else {
+                let _ = updateMediaAutoSaveSettingsInteractively(account: context.account, { settings in
+                    var settings = settings
+                    
+                    switch scope {
+                    case let .peer(peerId):
+                        if let index = settings.exceptions.firstIndex(where: { $0.id == peerId }) {
+                            switch type {
+                            case .photo:
+                                settings.exceptions[index].configuration.photo = !settings.exceptions[index].configuration.photo
+                            case .video:
+                                settings.exceptions[index].configuration.video = !settings.exceptions[index].configuration.video
+                            }
+                        }
+                    case .addPeer:
+                        break
+                    case let .peerType(peerType):
+                        let mappedType: MediaAutoSaveSettings.PeerType
+                        switch peerType {
+                        case .privateChats:
+                            mappedType = .users
+                        case .groups:
+                            mappedType = .groups
+                        case .channels:
+                            mappedType = .channels
+                        }
+                        var current = settings.configurations[mappedType] ?? .default
+                        
+                        switch type {
+                        case .photo:
+                            current.photo = !current.photo
+                        case .video:
+                            current.video = !current.video
+                        }
+                        
+                        settings.configurations[mappedType] = current
+                    }
+                    
+                    return settings
+                }).start()
+            }
+        },
+        updateMaximumVideoSize: { value in
+            if case .addPeer = scope {
+                updateState { state in
+                    var state = state
+                    
+                    state.pendingConfiguration.maximumVideoSize = value
+                    
+                    return state
+                }
+            } else {
+                let _ = updateMediaAutoSaveSettingsInteractively(account: context.account, { settings in
+                    var settings = settings
+                    
+                    switch scope {
+                    case let .peer(peerId):
+                        if let index = settings.exceptions.firstIndex(where: { $0.id == peerId }) {
+                            settings.exceptions[index].configuration.maximumVideoSize = value
+                        }
+                    case .addPeer:
+                        break
+                    case let .peerType(peerType):
+                        let mappedType: MediaAutoSaveSettings.PeerType
+                        switch peerType {
+                        case .privateChats:
+                            mappedType = .users
+                        case .groups:
+                            mappedType = .groups
+                        case .channels:
+                            mappedType = .channels
+                        }
+                        var current = settings.configurations[mappedType] ?? .default
+                        current.maximumVideoSize = value
+                        settings.configurations[mappedType] = current
+                    }
+                    
+                    return settings
+                }).start()
+            }
+        },
+        openAddException: {
+            guard case let .peerType(peerType) = scope else {
+                return
+            }
+            
+            let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+            var filter: ChatListNodePeersFilter = [.excludeRecent, .doNotSearchMessages, .removeSearchHeader]
+            switch peerType {
+            case .groups:
+                filter.insert(.onlyGroups)
+            case .privateChats:
+                filter.insert(.onlyPrivateChats)
+                filter.insert(.excludeSecretChats)
+            case .channels:
+                filter.insert(.onlyChannels)
+            }
+            let controller = context.sharedContext.makePeerSelectionController(PeerSelectionControllerParams(context: context, filter: filter, hasContactSelector: false, title: presentationData.strings.Notifications_AddExceptionTitle))
+            controller.peerSelected = { [weak controller] peer, _ in
+                let peerId = peer.id
+                
+                let preferencesKey: PostboxViewKey = .preferences(keys: Set([ApplicationSpecificPreferencesKeys.mediaAutoSaveSettings]))
+                let preferences = context.account.postbox.combinedView(keys: [preferencesKey])
+                |> map { views -> MediaAutoSaveSettings in
+                    guard let view = views.views[preferencesKey] as? PreferencesView else {
+                        return .default
+                    }
+                    return view.values[ApplicationSpecificPreferencesKeys.mediaAutoSaveSettings]?.get(MediaAutoSaveSettings.self) ?? MediaAutoSaveSettings.default
+                }
+                
+                let _ = (preferences
+                |> take(1)
+                |> deliverOnMainQueue).start(next: { settings in
+                    if settings.exceptions.contains(where: { $0.id == peerId }) {
+                        guard let controller = controller, let navigationController = controller.navigationController as? NavigationController else {
+                            return
+                        }
+                        var controllers = navigationController.viewControllers
+                        controllers = controllers.filter { item in
+                            if item === controller {
+                                return false
+                            }
+                            return true
+                        }
+                        controllers.append(saveIncomingMediaController(context: context, scope: .peer(peerId)))
+                        navigationController.setViewControllers(controllers, animated: true)
+                    } else {
+                        var dismissAll: (() -> Void)?
+                        let exceptionController = saveIncomingMediaController(context: context, scope: .addPeer(id: peerId, completion: { configuration in
+                            let _ = updateMediaAutoSaveSettingsInteractively(account: context.account, { settings in
+                                var settings = settings
+                                
+                                settings.exceptions.removeAll(where: { $0.id == peerId })
+                                settings.exceptions.insert(MediaAutoSaveSettings.ExceptionItem(id: peerId, configuration: configuration), at: 0)
+                                
+                                return settings
+                            }).start()
+                            
+                            dismissAll?()
+                        }))
+                        controller?.push(exceptionController)
+                        
+                        dismissAll = { [weak exceptionController] in
+                            guard let exceptionController = exceptionController else {
+                                return
+                            }
+                            guard let navigationController = exceptionController.navigationController as? NavigationController else {
+                                return
+                            }
+                            var controllers = navigationController.viewControllers
+                            controllers = controllers.filter { item in
+                                if item === exceptionController || item === controller {
+                                    return false
+                                }
+                                return true
+                            }
+                            navigationController.setViewControllers(controllers, animated: true)
+                        }
+                    }
+                })
+            }
+            pushController?(controller)
+        },
+        openPeerMenu: { peer in
+            pushController?(saveIncomingMediaController(context: context, scope: .peer(peer.id)))
+        },
+        setPeerIdWithRevealedOptions: { itemId, fromItemId in
+            updateState { state in
+                var state = state
+                if (itemId == nil && fromItemId == state.peerIdWithOptions) || (itemId != nil && fromItemId == nil) {
+                    state.peerIdWithOptions = itemId
+                }
+                return state
+            }
+        },
+        deletePeer: { id in
+            let _ = updateMediaAutoSaveSettingsInteractively(account: context.account, { settings in
+                var settings = settings
+                
+                settings.exceptions.removeAll(where: { $0.id == id })
+                
+                return settings
+            }).start()
+        },
+        deleteAllExceptions: {
+            let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+            let actionSheet = ActionSheetController(presentationData: presentationData)
+            actionSheet.setItemGroups([ActionSheetItemGroup(items: [
+                ActionSheetButtonItem(title: presentationData.strings.Autosave_DeleteAllExceptions, color: .destructive, action: { [weak actionSheet] in
+                    actionSheet?.dismissAnimated()
+                    
+                    let _ = updateMediaAutoSaveSettingsInteractively(account: context.account, { settings in
+                        var settings = settings
+                        
+                        settings.exceptions.removeAll()
+                        
+                        return settings
+                    }).start()
+                })
+            ]), ActionSheetItemGroup(items: [
+                ActionSheetButtonItem(title: presentationData.strings.Common_Cancel, color: .accent, font: .bold, action: { [weak actionSheet] in
+                    actionSheet?.dismissAnimated()
+                })
+            ])])
+            presentControllerImpl?(actionSheet)
+        }
+    )
+    
+    let preferencesKey: PostboxViewKey = .preferences(keys: Set([ApplicationSpecificPreferencesKeys.mediaAutoSaveSettings]))
+    let preferences = context.account.postbox.combinedView(keys: [preferencesKey])
+    |> map { views -> MediaAutoSaveSettings in
+        guard let view = views.views[preferencesKey] as? PreferencesView else {
+            return .default
+        }
+        return view.values[ApplicationSpecificPreferencesKeys.mediaAutoSaveSettings]?.get(MediaAutoSaveSettings.self) ?? MediaAutoSaveSettings.default
+    }
+    
+    let peer: Signal<(EnginePeer?, EnginePeer.Presence?), NoError>
+    switch scope {
+    case let .peer(id):
+        peer = context.engine.data.subscribe(
+            TelegramEngine.EngineData.Item.Peer.Peer(id: id),
+            TelegramEngine.EngineData.Item.Peer.Presence(id: id)
+        )
+    case let .addPeer(id, _):
+        peer = context.engine.data.subscribe(
+            TelegramEngine.EngineData.Item.Peer.Peer(id: id),
+            TelegramEngine.EngineData.Item.Peer.Presence(id: id)
+        )
+    default:
+        peer = .single((nil, nil))
+    }
+    
+    let autosaveExceptionPeers: Signal<[EnginePeer.Id: EnginePeer?], NoError> = preferences
+    |> mapToSignal { mediaAutoSaveSettings -> Signal<[EnginePeer.Id: EnginePeer?], NoError> in
+        let peerIds = mediaAutoSaveSettings.exceptions.map(\.id)
+        return context.engine.data.get(EngineDataMap(
+            peerIds.map(TelegramEngine.EngineData.Item.Peer.Peer.init(id:))
+        ))
+    }
+    
+    struct StoredState {
+        var entryCount: Int
+        var hasVideo: Bool
+    }
+    
+    let previousState = Atomic<StoredState?>(value: nil)
+    
+    let signal = combineLatest(queue: .mainQueue(), context.sharedContext.presentationData, statePromise.get(), preferences, peer, autosaveExceptionPeers)
+    |> deliverOnMainQueue
+    |> map { presentationData, state, mediaAutoSaveSettings, peer, autosaveExceptionPeers -> (ItemListControllerState, (ItemListNodeState, Any)) in
+        var rightButton: ItemListNavigationButton?
+        
+        switch scope {
+        case .peer, .addPeer:
+            rightButton = ItemListNavigationButton(content: .text(presentationData.strings.Common_Done), style: .bold, enabled: true, action: {
+                switch scope {
+                case let .addPeer(_, completion):
+                    let configuration = stateValue.with({ $0 }).pendingConfiguration
+                    completion(configuration)
+                default:
+                    dismiss?()
+                }
+            })
+        default:
+            break
+        }
+        
+        let configuration: MediaAutoSaveConfiguration
+        var exceptions: [MediaAutoSaveSettings.ExceptionItem] = []
+        let title: String
+        switch scope {
+        case let .peer(id):
+            if let data = mediaAutoSaveSettings.exceptions.first(where: { $0.id == id }) {
+                configuration = data.configuration
+            } else {
+                configuration = .default
+            }
+            title = presentationData.strings.Autosave_Exception
+        case .addPeer:
+            configuration = state.pendingConfiguration
+            title = presentationData.strings.Autosave_AddException
+        case let .peerType(peerType):
+            exceptions = mediaAutoSaveSettings.exceptions
+            switch peerType {
+            case .privateChats:
+                configuration = mediaAutoSaveSettings.configurations[.users] ?? .default
+                title = presentationData.strings.Notifications_PrivateChats
+            case .groups:
+                configuration = mediaAutoSaveSettings.configurations[.groups] ?? .default
+                title = presentationData.strings.Notifications_GroupChats
+            case .channels:
+                configuration = mediaAutoSaveSettings.configurations[.channels] ?? .default
+                title = presentationData.strings.Notifications_Channels
+            }
+        }
+        
+        let entries = saveIncomingMediaControllerEntries(presentationData: presentationData, scope: scope, state: state, peer: peer.0, peerPresence: peer.1, configuration: configuration, exceptions: exceptions, autosaveExceptionPeers: autosaveExceptionPeers)
+        
+        var animateChanges = false
+        let storedState = StoredState(
+            entryCount: entries.count,
+            hasVideo: entries.contains(where: { entry in
+                switch entry {
+                case .videoSize:
+                    return true
+                default:
+                    return false
+                }
+            })
+        )
+        if let previous = previousState.swap(storedState) {
+            if previous.entryCount > storedState.entryCount || previous.hasVideo != storedState.hasVideo {
+                animateChanges = true
+            }
+        }
+        
+        let controllerState = ItemListControllerState(presentationData: ItemListPresentationData(presentationData), title: .text(title), leftNavigationButton: nil, rightNavigationButton: rightButton, backNavigationButton: ItemListBackButton(title: presentationData.strings.Common_Back), animateChanges: false)
+        
+        let listState = ItemListNodeState(presentationData: ItemListPresentationData(presentationData), entries: entries, style: .blocks, emptyStateItem: nil, animateChanges: animateChanges)
+        
+        return (controllerState, (listState, arguments))
+    }
+    
+    let controller = ItemListController(context: context, state: signal)
+    
+    switch scope {
+    case .peer, .addPeer:
+        controller.navigationPresentation = .modal
+    default:
+        break
+    }
+    
+    pushController = { [weak controller] c in
+        controller?.push(c)
+    }
+    presentControllerImpl = { [weak controller] c in
+        controller?.present(c, in: .window(.root))
+    }
+    dismiss = { [weak controller] in
+        controller?.dismiss()
+    }
+    
+    return controller
+}
+

submodules/SettingsUI/Sources/Data and Storage/ShareProxyServerActionSheetController.swift

@@ -0,0 +1,185 @@
+import Foundation
+import UIKit
+import Display
+import TelegramCore
+import AsyncDisplayKit
+import UIKit
+import SwiftSignalKit
+import TelegramPresentationData
+import QrCode
+import ShareController
+
+public final class ShareProxyServerActionSheetController: ActionSheetController {
+    private var presentationDisposable: Disposable?
+    
+    private let _ready = Promise<Bool>()
+    override public var ready: Promise<Bool> {
+        return self._ready
+    }
+    
+    private var isDismissed: Bool = false
+        
+    public init(presentationData: PresentationData, updatedPresentationData: Signal<PresentationData, NoError>, link: String) {
+        let sheetTheme = ActionSheetControllerTheme(presentationData: presentationData)
+        super.init(theme: sheetTheme)
+        
+        let presentActivityController: (Any) -> Void = { [weak self] item in
+            let activityController = UIActivityViewController(activityItems: [item], applicationActivities: nil)
+            if let window = self?.view.window, let rootViewController = window.rootViewController {
+                activityController.popoverPresentationController?.sourceView = window
+                activityController.popoverPresentationController?.sourceRect = CGRect(origin: CGPoint(x: window.bounds.width / 2.0, y: window.bounds.size.height - 1.0), size: CGSize(width: 1.0, height: 1.0))
+                rootViewController.present(activityController, animated: true, completion: nil)
+            }
+        }
+        
+        var items: [ActionSheetItem] = []
+        items.append(ProxyServerQRCodeItem(strings: presentationData.strings, link: link, ready: { [weak self] in
+            self?._ready.set(.single(true))
+        }))
+        items.append(ActionSheetButtonItem(title: presentationData.strings.SocksProxySetup_ShareQRCode, action: { [weak self] in
+            self?.dismissAnimated()
+            let _ = (qrCode(string: link, color: .black, backgroundColor: .white, icon: .proxy)
+            |> map { _, generator -> UIImage? in
+                let imageSize = CGSize(width: 768.0, height: 768.0)
+                let context = generator(TransformImageArguments(corners: ImageCorners(), imageSize: imageSize, boundingSize: imageSize, intrinsicInsets: UIEdgeInsets(), scale: 1.0))
+                return context?.generateImage()
+            }
+            |> deliverOnMainQueue).start(next: { image in
+                if let image = image {
+                    presentActivityController(image)
+                }
+            })
+        }))
+        items.append(ActionSheetButtonItem(title: presentationData.strings.SocksProxySetup_ShareLink, action: { [weak self] in
+            self?.dismissAnimated()
+            presentActivityController(link)
+        }))
+        self.setItemGroups([
+            ActionSheetItemGroup(items: items),
+            ActionSheetItemGroup(items: [
+                ActionSheetButtonItem(title: presentationData.strings.Common_Cancel, action: { [weak self] in
+                    self?.dismissAnimated()
+                })
+                ])
+            ])
+        
+        self.presentationDisposable = updatedPresentationData.start(next: { [weak self] presentationData in
+            if let strongSelf = self {
+                strongSelf.theme = ActionSheetControllerTheme(presentationData: presentationData)
+            }
+        })
+    }
+    
+    required public init(coder aDecoder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+    
+    deinit {
+        self.presentationDisposable?.dispose()
+    }
+}
+
+private final class ProxyServerQRCodeItem: ActionSheetItem {
+    private let strings: PresentationStrings
+    private let link: String
+    private let ready: () -> Void
+    
+    init(strings: PresentationStrings, link: String, ready: @escaping () -> Void = {}) {
+        self.strings = strings
+        self.link = link
+        self.ready = ready
+    }
+    
+    func node(theme: ActionSheetControllerTheme) -> ActionSheetItemNode {
+        return ProxyServerQRCodeItemNode(theme: theme, strings: self.strings, link: self.link, ready: self.ready)
+    }
+    
+    func updateNode(_ node: ActionSheetItemNode) {
+    }
+}
+
+private final class ProxyServerQRCodeItemNode: ActionSheetItemNode {
+    private let theme: ActionSheetControllerTheme
+    private let strings: PresentationStrings
+    private let link: String
+    
+    private let label: ASTextNode
+    private let imageNode: TransformImageNode
+    
+    private let ready: () -> Void
+    
+    private var cachedHasLabel = true
+    private var cachedHasImage = true
+    
+    init(theme: ActionSheetControllerTheme, strings: PresentationStrings, link: String, ready: @escaping () -> Void = {}) {
+        self.theme = theme
+        self.strings = strings
+        self.link = link
+        self.ready = ready
+        
+        let textFont = Font.regular(floor(theme.baseFontSize * 13.0 / 17.0))
+        
+        self.label = ASTextNode()
+        self.label.isUserInteractionEnabled = false
+        self.label.maximumNumberOfLines = 0
+        self.label.displaysAsynchronously = false
+        self.label.truncationMode = .byTruncatingTail
+        self.label.isUserInteractionEnabled = false
+        self.label.attributedText = NSAttributedString(string: strings.SocksProxySetup_ShareQRCodeInfo, font: textFont, textColor: self.theme.secondaryTextColor, paragraphAlignment: .center)
+        
+        self.imageNode = TransformImageNode()
+        self.imageNode.clipsToBounds = true
+        self.imageNode.setSignal(qrCode(string: link, color: .black, backgroundColor: .white, icon: .proxy) |> map { $0.1 }, attemptSynchronously: true)
+        self.imageNode.cornerRadius = 14.0
+        
+        super.init(theme: theme)
+        
+        self.addSubnode(self.label)
+        self.addSubnode(self.imageNode)
+    }
+    
+    override func updateLayout(constrainedSize: CGSize, transition: ContainedViewLayoutTransition) -> CGSize {
+        let imageInset: CGFloat = 44.0
+        let side = constrainedSize.width - imageInset * 2.0
+        var imageSize = CGSize(width: side, height: side)
+        
+        let makeLayout = self.imageNode.asyncLayout()
+        let apply = makeLayout(TransformImageArguments(corners: ImageCorners(), imageSize: imageSize, boundingSize: imageSize, intrinsicInsets: UIEdgeInsets(), emptyColor: nil))
+        apply()
+        
+        var labelSize = self.label.measure(CGSize(width: max(1.0, constrainedSize.width - 64.0), height: constrainedSize.height))
+        
+        self.cachedHasImage = constrainedSize.width < constrainedSize.height
+        if !self.cachedHasImage {
+            imageSize = CGSize()
+        }
+        
+        self.ready()
+        
+        self.cachedHasLabel = constrainedSize.height > 480 || !self.cachedHasImage
+        if !self.cachedHasLabel {
+            labelSize = CGSize()
+        }
+        let size = CGSize(width: constrainedSize.width, height: 14.0 + (labelSize.height > 0.0 ? labelSize.height + 14.0 : 0.0) + (imageSize.height > 0.0 ? imageSize.height + 14.0 : 8.0))
+        
+        let inset: CGFloat = 32.0
+        let spacing: CGFloat = 18.0
+        if self.cachedHasLabel {
+            labelSize = self.label.measure(CGSize(width: max(1.0, size.width - inset * 2.0), height: size.height))
+            self.label.frame = CGRect(origin: CGPoint(x: floorToScreenPixels((size.width - labelSize.width) / 2.0), y: spacing), size: labelSize)
+        } else {
+            labelSize = CGSize()
+        }
+        
+        if !self.cachedHasImage {
+            imageSize = CGSize()
+        } else {
+            imageSize =  CGSize(width: size.width - imageInset * 2.0, height: size.width - imageInset * 2.0)
+        }
+        let imageOrigin = CGPoint(x: imageInset, y: self.label.frame.maxY + spacing - 4.0)
+        self.imageNode.frame = CGRect(origin: imageOrigin, size: imageSize)
+
+        self.updateInternalLayout(size, constrainedSize: constrainedSize)
+        return size
+    }
+}

submodules/SettingsUI/Sources/Data and Storage/StorageUsageExceptionsScreen.swift

@@ -0,0 +1,516 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import Postbox
+import TelegramCore
+import TelegramPresentationData
+import TelegramUIPreferences
+import TelegramStringFormatting
+import ItemListUI
+import PresentationDataUtils
+import OverlayStatusController
+import AccountContext
+import ItemListPeerItem
+import UndoUI
+import ContextUI
+import ItemListPeerActionItem
+
+private enum StorageUsageExceptionsEntryTag: Hashable, ItemListItemTag {
+    case peer(EnginePeer.Id)
+    
+    public func isEqual(to other: ItemListItemTag) -> Bool {
+        if let other = other as? StorageUsageExceptionsEntryTag, self == other {
+            return true
+        } else {
+            return false
+        }
+    }
+}
+
+private final class StorageUsageExceptionsScreenArguments {
+    let context: AccountContext
+    let openAddException: () -> Void
+    let openPeerMenu: (EnginePeer.Id, Int32) -> Void
+    
+    init(
+        context: AccountContext,
+        openAddException: @escaping () -> Void,
+        openPeerMenu: @escaping (EnginePeer.Id, Int32) -> Void
+    ) {
+        self.context = context
+        self.openAddException = openAddException
+        self.openPeerMenu = openPeerMenu
+    }
+}
+
+private enum StorageUsageExceptionsSection: Int32 {
+    case add
+    case items
+}
+
+private enum StorageUsageExceptionsEntry: ItemListNodeEntry {
+    enum SortIndex: Equatable, Comparable {
+        case index(Int)
+        case peer(index: Int, peerId: EnginePeer.Id)
+        
+        static func <(lhs: SortIndex, rhs: SortIndex) -> Bool {
+            switch lhs {
+            case let .index(index):
+                if case let .index(rhsIndex) = rhs {
+                    return index < rhsIndex
+                } else {
+                    return true
+                }
+            case let .peer(index, peerId):
+                if case let .peer(rhsIndex, rhsPeerId) = rhs {
+                    if index != rhsIndex {
+                        return index < rhsIndex
+                    } else {
+                        return peerId < rhsPeerId
+                    }
+                } else {
+                    return false
+                }
+            }
+        }
+    }
+    
+    enum StableId: Hashable {
+        case index(Int)
+        case peer(EnginePeer.Id)
+    }
+    
+    case addException(String)
+    case exceptionsHeader(String)
+    case peer(index: Int, peer: FoundPeer, value: Int32)
+    
+    var section: ItemListSectionId {
+        switch self {
+        case .addException:
+            return StorageUsageExceptionsSection.add.rawValue
+        case .exceptionsHeader, .peer:
+            return StorageUsageExceptionsSection.items.rawValue
+        }
+    }
+    
+    var stableId: StableId {
+        switch self {
+        case .addException:
+            return .index(0)
+        case .exceptionsHeader:
+            return .index(1)
+        case let .peer(_, peer, _):
+            return .peer(peer.peer.id)
+        }
+    }
+    
+    var sortIndex: SortIndex {
+        switch self {
+        case .addException:
+            return .index(0)
+        case .exceptionsHeader:
+            return .index(1)
+        case let .peer(index, peer, _):
+            return .peer(index: index, peerId: peer.peer.id)
+        }
+    }
+    
+    static func ==(lhs: StorageUsageExceptionsEntry, rhs: StorageUsageExceptionsEntry) -> Bool {
+        switch lhs {
+        case let .addException(text):
+            if case .addException(text) = rhs {
+                return true
+            } else {
+                return false
+            }
+        case let .exceptionsHeader(text):
+            if case .exceptionsHeader(text) = rhs {
+                return true
+            } else {
+                return false
+            }
+        case let .peer(index, peer, value):
+            if case .peer(index, peer, value) = rhs {
+                return true
+            } else {
+                return false
+            }
+        }
+    }
+    
+    static func <(lhs: StorageUsageExceptionsEntry, rhs: StorageUsageExceptionsEntry) -> Bool {
+        return lhs.sortIndex < rhs.sortIndex
+    }
+    
+    func item(presentationData: ItemListPresentationData, arguments: Any) -> ListViewItem {
+        let arguments = arguments as! StorageUsageExceptionsScreenArguments
+        switch self {
+        case let .addException(text):
+            let icon: UIImage? = PresentationResourcesItemList.createGroupIcon(presentationData.theme)
+            return ItemListPeerActionItem(presentationData: presentationData, icon: icon, title: text, alwaysPlain: false, sectionId: self.section, editing: false, action: {
+                arguments.openAddException()
+            })
+        case let .exceptionsHeader(text):
+            return ItemListSectionHeaderItem(presentationData: presentationData, text: text, sectionId: self.section)
+        case let .peer(_, peer, value):
+            var additionalDetailLabel: String?
+            if let subscribers = peer.subscribers {
+                additionalDetailLabel = presentationData.strings.VoiceChat_Panel_Members(subscribers)
+            }
+            let optionText: String
+            if value == Int32.max {
+                optionText = presentationData.strings.ClearCache_Forever
+            } else {
+                optionText = timeIntervalString(strings: presentationData.strings, value: value)
+            }
+            
+            let title: String
+            if peer.peer.id == arguments.context.account.peerId {
+                title = presentationData.strings.DialogList_SavedMessages
+            } else {
+                title = EnginePeer(peer.peer).displayTitle(strings: presentationData.strings, displayOrder: .firstLast)
+            }
+            
+            return ItemListDisclosureItem(presentationData: presentationData, icon: nil, context: arguments.context, iconPeer: EnginePeer(peer.peer), title: title, enabled: true, titleFont: .bold, label: optionText, labelStyle: .text, additionalDetailLabel: additionalDetailLabel, sectionId: self.section, style: .blocks, disclosureStyle: .optionArrows, action: {
+                arguments.openPeerMenu(peer.peer.id, value)
+            }, tag: StorageUsageExceptionsEntryTag.peer(peer.peer.id))
+        }
+    }
+}
+
+private struct StorageUsageExceptionsState: Equatable {
+}
+
+private func storageUsageExceptionsScreenEntries(
+    presentationData: PresentationData,
+    peerExceptions: [(peer: FoundPeer, value: Int32)],
+    state: StorageUsageExceptionsState
+) -> [StorageUsageExceptionsEntry] {
+    var entries: [StorageUsageExceptionsEntry] = []
+    
+    entries.append(.addException(presentationData.strings.Notification_Exceptions_AddException))
+    
+    if !peerExceptions.isEmpty {
+        entries.append(.exceptionsHeader(presentationData.strings.Notifications_CategoryExceptions(Int32(peerExceptions.count)).uppercased()))
+        
+        var index = 100
+        for item in peerExceptions {
+            entries.append(.peer(index: index, peer: item.peer, value: item.value))
+            index += 1
+        }
+    }
+    
+    return entries
+}
+
+public func storageUsageExceptionsScreen(
+    context: AccountContext,
+    category: CacheStorageSettings.PeerStorageCategory,
+    isModal: Bool = false
+) -> ViewController {
+    let statePromise = ValuePromise(StorageUsageExceptionsState())
+    let stateValue = Atomic(value: StorageUsageExceptionsState())
+    let updateState: ((StorageUsageExceptionsState) -> StorageUsageExceptionsState) -> Void = { f in
+        statePromise.set(stateValue.modify { f($0) })
+    }
+    let _ = updateState
+    
+    let cacheSettingsPromise = Promise<CacheStorageSettings>()
+    cacheSettingsPromise.set(context.sharedContext.accountManager.sharedData(keys: [SharedDataKeys.cacheStorageSettings])
+    |> map { sharedData -> CacheStorageSettings in
+        let cacheSettings: CacheStorageSettings
+        if let value = sharedData.entries[SharedDataKeys.cacheStorageSettings]?.get(CacheStorageSettings.self) {
+            cacheSettings = value
+        } else {
+            cacheSettings = CacheStorageSettings.defaultSettings
+        }
+        
+        return cacheSettings
+    })
+    
+    let viewKey: PostboxViewKey = .preferences(keys: Set([PreferencesKeys.accountSpecificCacheStorageSettings]))
+    let accountSpecificSettings: Signal<AccountSpecificCacheStorageSettings, NoError> = context.account.postbox.combinedView(keys: [viewKey])
+    |> map { views -> AccountSpecificCacheStorageSettings in
+        let cacheSettings: AccountSpecificCacheStorageSettings
+        if let view = views.views[viewKey] as? PreferencesView, let value = view.values[PreferencesKeys.accountSpecificCacheStorageSettings]?.get(AccountSpecificCacheStorageSettings.self) {
+            cacheSettings = value
+        } else {
+            cacheSettings = AccountSpecificCacheStorageSettings.defaultSettings
+        }
+
+        return cacheSettings
+    }
+    |> distinctUntilChanged
+    
+    let peerExceptions: Signal<[(peer: FoundPeer, value: Int32)], NoError> = accountSpecificSettings
+    |> mapToSignal { accountSpecificSettings -> Signal<[(peer: FoundPeer, value: Int32)], NoError> in
+        return context.account.postbox.transaction { transaction -> [(peer: FoundPeer, value: Int32)] in
+            var result: [(peer: FoundPeer, value: Int32)] = []
+            
+            for item in accountSpecificSettings.peerStorageTimeoutExceptions {
+                let peerId = item.key
+                let value = item.value
+                
+                guard let peer = transaction.getPeer(peerId) else {
+                    continue
+                }
+                let peerCategory: CacheStorageSettings.PeerStorageCategory
+                var subscriberCount: Int32?
+                if peer is TelegramUser {
+                    peerCategory = .privateChats
+                } else if peer is TelegramGroup {
+                    peerCategory = .groups
+                    
+                    if let cachedData = transaction.getPeerCachedData(peerId: peerId) as? CachedGroupData {
+                        subscriberCount = (cachedData.participants?.participants.count).flatMap(Int32.init)
+                    }
+                } else if let channel = peer as? TelegramChannel {
+                    if case .group = channel.info {
+                        peerCategory = .groups
+                    } else {
+                        peerCategory = .channels
+                    }
+                    if peerCategory == category {
+                        if let cachedData = transaction.getPeerCachedData(peerId: peerId) as? CachedChannelData {
+                            subscriberCount = cachedData.participantsSummary.memberCount
+                        }
+                    }
+                } else {
+                    continue
+                }
+                    
+                if peerCategory != category {
+                    continue
+                }
+                
+                result.append((peer: FoundPeer(peer: peer, subscribers: subscriberCount), value: value))
+            }
+            
+            return result.sorted(by: { lhs, rhs in
+                if lhs.value != rhs.value {
+                    return lhs.value < rhs.value
+                }
+                return lhs.peer.peer.debugDisplayTitle < rhs.peer.peer.debugDisplayTitle
+            })
+        }
+    }
+    
+    var presentControllerImpl: ((ViewController, PresentationContextType, Any?) -> Void)?
+    let _ = presentControllerImpl
+    var pushControllerImpl: ((ViewController) -> Void)?
+    
+    var findPeerReferenceNode: ((EnginePeer.Id) -> ItemListDisclosureItemNode?)?
+    let _ = findPeerReferenceNode
+    
+    var presentInGlobalOverlay: ((ViewController) -> Void)?
+    let _ = presentInGlobalOverlay
+    
+    let actionDisposables = DisposableSet()
+    
+    let clearDisposable = MetaDisposable()
+    actionDisposables.add(clearDisposable)
+    
+    let arguments = StorageUsageExceptionsScreenArguments(
+        context: context,
+        openAddException: {
+            let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+            var filter: ChatListNodePeersFilter = [.excludeRecent, .doNotSearchMessages, .removeSearchHeader]
+            switch category {
+            case .groups:
+                filter.insert(.onlyGroups)
+            case .privateChats:
+                filter.insert(.onlyPrivateChats)
+                filter.insert(.excludeSecretChats)
+            case .channels:
+                filter.insert(.onlyChannels)
+            case .stories:
+                filter.insert(.onlyPrivateChats)
+            }
+            let controller = context.sharedContext.makePeerSelectionController(PeerSelectionControllerParams(context: context, filter: filter, hasContactSelector: false, title: presentationData.strings.Notifications_AddExceptionTitle))
+            controller.peerSelected = { [weak controller] peer, _ in
+                let peerId = peer.id
+                
+                let _ = updateAccountSpecificCacheStorageSettingsInteractively(postbox: context.account.postbox, { settings in
+                    var settings = settings
+                    
+                    for i in 0 ..< settings.peerStorageTimeoutExceptions.count {
+                        if settings.peerStorageTimeoutExceptions[i].key == peerId {
+                            settings.peerStorageTimeoutExceptions.remove(at: i)
+                            break
+                        }
+                    }
+                    settings.peerStorageTimeoutExceptions.append(AccountSpecificCacheStorageSettings.Value(key: peerId, value: Int32.max))
+                    
+                    return settings
+                }).start()
+                
+                controller?.dismiss()
+            }
+            pushControllerImpl?(controller)
+        },
+        openPeerMenu: { peerId, currentValue in
+            let applyValue: (Int32?) -> Void = { value in
+                let _ = updateAccountSpecificCacheStorageSettingsInteractively(postbox: context.account.postbox, { settings in
+                    var settings = settings
+                    
+                    if let value = value {
+                        var found = false
+                        for i in 0 ..< settings.peerStorageTimeoutExceptions.count {
+                            if settings.peerStorageTimeoutExceptions[i].key == peerId {
+                                found = true
+                                settings.peerStorageTimeoutExceptions[i] = AccountSpecificCacheStorageSettings.Value(key: peerId, value: value)
+                                break
+                            }
+                        }
+                        if !found {
+                            settings.peerStorageTimeoutExceptions.append(AccountSpecificCacheStorageSettings.Value(key: peerId, value: value))
+                        }
+                    } else {
+                        for i in 0 ..< settings.peerStorageTimeoutExceptions.count {
+                            if settings.peerStorageTimeoutExceptions[i].key == peerId {
+                                settings.peerStorageTimeoutExceptions.remove(at: i)
+                                break
+                            }
+                        }
+                    }
+                    
+                    return settings
+                }).start()
+            }
+            
+            var subItems: [ContextMenuItem] = []
+            let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+            
+            let presetValues: [Int32] = [
+                Int32.max,
+                31 * 24 * 60 * 60,
+                7 * 24 * 60 * 60,
+                1 * 24 * 60 * 60
+            ]
+            
+            for value in presetValues {
+                let optionText: String
+                if value == Int32.max {
+                    optionText = presentationData.strings.ClearCache_Forever
+                } else {
+                    optionText = timeIntervalString(strings: presentationData.strings, value: value)
+                }
+                subItems.append(.action(ContextMenuActionItem(text: optionText, icon: { theme in
+                    if currentValue == value {
+                        return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Check"), color: theme.contextMenu.primaryColor)
+                    } else {
+                        return nil
+                    }
+                }, action: { _, f in
+                    applyValue(value)
+                    f(.default)
+                })))
+            }
+            
+            subItems.append(.separator)
+            subItems.append(.action(ContextMenuActionItem(text: presentationData.strings.VoiceChat_RemovePeer, textColor: .destructive, icon: { theme in
+                return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Delete"), color: theme.contextMenu.destructiveColor)
+            }, action: { _, f in
+                f(.default)
+                
+                applyValue(nil)
+            })))
+            
+            if let sourceNode = findPeerReferenceNode?(peerId) {
+                let items: Signal<ContextController.Items, NoError> = .single(ContextController.Items(content: .list(subItems)))
+                let source: ContextContentSource = .reference(StorageUsageExceptionsContextReferenceContentSource(sourceView: sourceNode.labelNode.view))
+                
+                let contextController = ContextController(
+                    presentationData: presentationData,
+                    source: source,
+                    items: items,
+                    gesture: nil
+                )
+                sourceNode.updateHasContextMenu(hasContextMenu: true)
+                contextController.dismissed = { [weak sourceNode] in
+                    sourceNode?.updateHasContextMenu(hasContextMenu: false)
+                }
+                presentInGlobalOverlay?(contextController)
+            }
+        }
+    )
+    
+    let _ = cacheSettingsPromise
+    
+    var dismissImpl: (() -> Void)?
+    
+    let signal = combineLatest(queue: .mainQueue(),
+        context.sharedContext.presentationData,
+        peerExceptions,
+        statePromise.get()
+    )
+    |> deliverOnMainQueue
+    |> map { presentationData, peerExceptions, state -> (ItemListControllerState, (ItemListNodeState, Any)) in
+        let leftNavigationButton = isModal ? ItemListNavigationButton(content: .text(presentationData.strings.Common_Cancel), style: .regular, enabled: true, action: {
+            dismissImpl?()
+        }) : nil
+        
+        let controllerState = ItemListControllerState(presentationData: ItemListPresentationData(presentationData), title: .text(presentationData.strings.Notifications_ExceptionsTitle), leftNavigationButton: leftNavigationButton, rightNavigationButton: nil, backNavigationButton: ItemListBackButton(title: presentationData.strings.Common_Back), animateChanges: false)
+        let listState = ItemListNodeState(presentationData: ItemListPresentationData(presentationData), entries: storageUsageExceptionsScreenEntries(presentationData: presentationData, peerExceptions: peerExceptions, state: state), style: .blocks, emptyStateItem: nil, animateChanges: false)
+        
+        return (controllerState, (listState, arguments))
+    }
+    |> afterDisposed {
+        actionDisposables.dispose()
+    }
+    
+    let controller = ItemListController(context: context, state: signal)
+    if isModal {
+        controller.navigationPresentation = .modal
+        controller.supportedOrientations = ViewControllerSupportedOrientations(regularSize: .all, compactSize: .portrait)
+    }
+    presentControllerImpl = { [weak controller] c, contextType, a in
+        controller?.present(c, in: contextType, with: a)
+    }
+    pushControllerImpl = { [weak controller] c in
+        controller?.push(c)
+    }
+    presentInGlobalOverlay = { [weak controller] c in
+        controller?.presentInGlobalOverlay(c, with: nil)
+    }
+    findPeerReferenceNode = { [weak controller] peerId in
+        guard let controller else {
+            return nil
+        }
+        
+        let targetTag: StorageUsageExceptionsEntryTag = .peer(peerId)
+        var resultItemNode: ItemListItemNode?
+        controller.forEachItemNode { itemNode in
+            if let itemNode = itemNode as? ItemListItemNode {
+                if let tag = itemNode.tag, tag.isEqual(to: targetTag) {
+                    resultItemNode = itemNode
+                    return
+                }
+            }
+        }
+        
+        if let resultItemNode = resultItemNode as? ItemListDisclosureItemNode {
+            return resultItemNode
+        } else {
+            return nil
+        }
+    }
+    dismissImpl = { [weak controller] in
+        controller?.dismiss()
+    }
+    return controller
+}
+
+private final class StorageUsageExceptionsContextReferenceContentSource: ContextReferenceContentSource {
+    private let sourceView: UIView
+    
+    init(sourceView: UIView) {
+        self.sourceView = sourceView
+    }
+    
+    func transitionInfo() -> ContextControllerReferenceViewInfo? {
+        return ContextControllerReferenceViewInfo(referenceView: self.sourceView, contentAreaInScreenSpace: UIScreen.main.bounds, insets: UIEdgeInsets(top: -4.0, left: 0.0, bottom: -4.0, right: 0.0))
+    }
+}

submodules/SettingsUI/Sources/Data and Storage/StorageUsageItem.swift

@@ -0,0 +1,320 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import TelegramCore
+import TelegramUIPreferences
+import TelegramPresentationData
+import ItemListUI
+import PresentationDataUtils
+
+struct StorageUsageCategory: Equatable {
+    let title: String
+    let size: Int64
+    let fraction: CGFloat
+    let color: UIColor
+}
+
+final class StorageUsageItem: ListViewItem, ItemListItem {
+    let theme: PresentationTheme
+    let strings: PresentationStrings
+    let dateTimeFormat: PresentationDateTimeFormat
+    let categories: [StorageUsageCategory]
+    let sectionId: ItemListSectionId
+    
+    init(theme: PresentationTheme, strings: PresentationStrings, dateTimeFormat: PresentationDateTimeFormat, categories: [StorageUsageCategory], sectionId: ItemListSectionId) {
+        self.theme = theme
+        self.strings = strings
+        self.dateTimeFormat = dateTimeFormat
+        self.categories = categories
+        self.sectionId = sectionId
+    }
+    
+    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 = StorageUsageItemNode()
+            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 {
+            if let nodeValue = node() as? StorageUsageItemNode {
+                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 func generateDotImage(color: UIColor) -> UIImage? {
+    return generateImage(CGSize(width: 8.0, height: 8.0), rotatedContext: { size, context in
+        let bounds = CGRect(origin: CGPoint(), size: size)
+        context.clear(bounds)
+        context.setFillColor(color.cgColor)
+        context.fillEllipse(in: bounds)
+    })
+}
+
+private func generateLineMaskImage(color: UIColor) -> UIImage? {
+    return generateImage(CGSize(width: 8.0, height: 8.0), rotatedContext: { size, context in
+        let bounds = CGRect(origin: CGPoint(), size: size)
+        context.setFillColor(color.cgColor)
+        context.fill(bounds)
+
+        context.setBlendMode(.clear)
+        context.setFillColor(UIColor.clear.cgColor)
+        context.fillEllipse(in: bounds)
+    })?.stretchableImage(withLeftCapWidth: 4, topCapHeight: 4)
+}
+
+private final class StorageUsageItemNode: ListViewItemNode {
+    private let backgroundNode: ASDisplayNode
+    private let topStripeNode: ASDisplayNode
+    private let bottomStripeNode: ASDisplayNode
+    private let maskNode: ASImageNode
+    
+    private let lineMaskNode: ASImageNode
+    private var lineNodes: [ASDisplayNode]
+    private var descriptionNodes: [(ASImageNode, TextNode)]
+
+    private var item: StorageUsageItem?
+    private var layoutParams: ListViewItemLayoutParams?
+
+    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.lineMaskNode = ASImageNode()
+        self.lineMaskNode.displaysAsynchronously = false
+        self.lineMaskNode.displayWithoutProcessing = true
+        self.lineMaskNode.contentMode = .scaleToFill
+        
+        self.lineNodes = []
+        self.descriptionNodes = []
+        
+        super.init(layerBacked: false, dynamicBounce: false)
+        
+        self.addSubnode(self.lineMaskNode)
+    }
+    
+    func asyncLayout() -> (_ item: StorageUsageItem, _ params: ListViewItemLayoutParams, _ neighbors: ItemListNeighbors) -> (ListViewItemNodeLayout, () -> Void) {
+        let currentItem = self.item
+        
+        return { [weak self] item, params, neighbors in
+            if let strongSelf = self, strongSelf.lineNodes.count != item.categories.count {
+                for node in strongSelf.lineNodes {
+                    node.removeFromSupernode()
+                }
+                
+                strongSelf.lineNodes = []
+                
+                for pair in strongSelf.descriptionNodes {
+                    pair.0.removeFromSupernode()
+                    pair.1.removeFromSupernode()
+                }
+                
+                strongSelf.descriptionNodes = []
+                
+                for _ in item.categories {
+                    let lineNode = ASDisplayNode()
+                    strongSelf.insertSubnode(lineNode, belowSubnode: strongSelf.lineMaskNode)
+                    strongSelf.lineNodes.append(lineNode)
+                    
+                    let dotNode = ASImageNode()
+                    dotNode.displaysAsynchronously = false
+                    dotNode.displayWithoutProcessing = true
+                    strongSelf.addSubnode(dotNode)
+                    
+                    let textNode = TextNode()
+                    strongSelf.addSubnode(textNode)
+                    
+                    strongSelf.descriptionNodes.append((dotNode, textNode))
+                }
+            }
+            
+            var makeNodesLayout: [(TextNodeLayoutArguments) -> (TextNodeLayout, () -> TextNode)] = []
+            if let strongSelf = self {
+                for nodes in strongSelf.descriptionNodes {
+                    let makeTextLayout = TextNode.asyncLayout(nodes.1)
+                    makeNodesLayout.append(makeTextLayout)
+                }
+            }
+            
+            var themeUpdated = false
+            if currentItem?.theme !== item.theme {
+                themeUpdated = true
+            }
+            
+            let contentSize: CGSize
+            let insets: UIEdgeInsets
+            let separatorHeight = UIScreenPixel
+                        
+            var textFramesApplies: [(CGRect, () -> TextNode)] = []
+            
+            let inset: CGFloat = 16.0
+            let horizontalSpacing: CGFloat = 32.0
+            let verticalSpacing: CGFloat = 22.0
+            var textOrigin: CGPoint = CGPoint(x: params.leftInset + horizontalSpacing, y: 52.0)
+            
+            for i in 0 ..< item.categories.count {
+                let makeTextLayout = makeNodesLayout[i]
+                let category = item.categories[i]
+                
+                let attributedString = NSMutableAttributedString(string: category.title, font: Font.regular(14.0), textColor: item.theme.list.itemPrimaryTextColor, paragraphAlignment: .natural)
+                attributedString.append(NSAttributedString(string: " • \(dataSizeString(category.size, forceDecimal: true, formatting: DataSizeStringFormatting(strings: item.strings, decimalSeparator: item.dateTimeFormat.decimalSeparator)))", font: Font.bold(14.0), textColor: item.theme.list.itemPrimaryTextColor))
+                
+                let (textLayout, textApply) = makeTextLayout(TextNodeLayoutArguments(attributedString: attributedString, backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width - params.leftInset - params.rightInset - 60.0, height: CGFloat.greatestFiniteMagnitude), alignment: .natural, cutout: nil, insets: UIEdgeInsets()))
+                
+                var textFrame = CGRect(origin: textOrigin, size: textLayout.size)
+                if textFrame.maxX > params.width - params.rightInset - inset {
+                    textFrame.origin = CGPoint(x: params.leftInset + horizontalSpacing, y: textOrigin.y + verticalSpacing)
+                }
+ 
+                textOrigin = CGPoint(x: textFrame.maxX + horizontalSpacing, y: textFrame.minY)
+                
+                textFramesApplies.append((textFrame, textApply))
+            }
+            
+            contentSize = CGSize(width: params.width, height: textOrigin.y + 34.0)
+            insets = itemListNeighborsGroupedInsets(neighbors, params)
+            
+            let layout = ListViewItemNodeLayout(contentSize: contentSize, insets: insets)
+            let layoutSize = layout.size
+            
+            return (layout, { [weak self] in
+                if let strongSelf = self {
+                    strongSelf.item = item
+                    strongSelf.layoutParams = params
+                    
+                    strongSelf.backgroundNode.backgroundColor = item.theme.list.itemBlocksBackgroundColor
+                    strongSelf.topStripeNode.backgroundColor = item.theme.list.itemBlocksSeparatorColor
+                    strongSelf.bottomStripeNode.backgroundColor = item.theme.list.itemBlocksSeparatorColor
+                    
+                    if themeUpdated {
+                        strongSelf.lineMaskNode.image = generateLineMaskImage(color: item.theme.list.itemBlocksBackgroundColor)
+                    }
+                    
+                    for (_, textApply) in textFramesApplies {
+                        let _ = textApply()
+                    }
+                    
+                    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.insertSubnode(strongSelf.maskNode, at: 3)
+                    }
+                    
+                    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 = 0.0
+                            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.theme, top: hasTopCorners, bottom: hasBottomCorners) : 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.maskNode.frame = strongSelf.backgroundNode.frame.insetBy(dx: params.leftInset, dy: 0.0)
+                    strongSelf.topStripeNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: layoutSize.width, height: separatorHeight))
+                    strongSelf.bottomStripeNode.frame = CGRect(origin: CGPoint(x: bottomStripeInset, y: contentSize.height + bottomStripeOffset), size: CGSize(width: layoutSize.width - bottomStripeInset, height: separatorHeight))
+                    
+                    let lineInset: CGFloat = params.leftInset + 12.0
+                    var lineOrigin = CGPoint(x: lineInset, y: 16.0)
+                    let lineWidth = params.width - lineOrigin.x * 2.0
+                    
+                    strongSelf.lineMaskNode.frame = CGRect(origin: lineOrigin, size: CGSize(width: lineWidth, height: 21.0))
+                    
+                    for i in 0 ..< strongSelf.lineNodes.count {
+                        let lineNode = strongSelf.lineNodes[i]
+                        let category = item.categories[i]
+                        
+                        lineNode.backgroundColor = category.color
+                        
+                        var categoryWidth = max(floor(lineWidth * category.fraction), 2.0)
+                        if i == strongSelf.lineNodes.count - 1 {
+                            categoryWidth = max(0.0, lineWidth - (lineOrigin.x - lineInset))
+                        }
+                        
+                        let lineRect = CGRect(origin: lineOrigin, size: CGSize(width: categoryWidth, height: 21.0))
+                        lineNode.frame = lineRect
+                        
+                        lineOrigin.x += lineRect.width + 1.0
+                    }
+                    
+                    for i in 0 ..< strongSelf.descriptionNodes.count {
+                        let dotNode = strongSelf.descriptionNodes[i].0
+                        let textNode = strongSelf.descriptionNodes[i].1
+                        let textFrame = textFramesApplies[i].0
+                        let category = item.categories[i]
+                        
+                        if dotNode.image == nil || themeUpdated {
+                            dotNode.image = generateDotImage(color: category.color)
+                        }
+                        dotNode.frame = CGRect(x: textFrame.minX - 16.0, y: textFrame.minY + 4.0, width: 8.0, height: 8.0)
+                        
+                        textNode.frame = textFrame
+                    }
+                }
+            })
+        }
+    }
+      
+      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)
+      }
+}

submodules/SettingsUI/Sources/Data and Storage/VoiceCallDataSavingController.swift

@@ -0,0 +1,165 @@
+import Foundation
+import UIKit
+import Display
+import SwiftSignalKit
+import Postbox
+import TelegramCore
+import TelegramPresentationData
+import TelegramUIPreferences
+import ItemListUI
+import PresentationDataUtils
+import AccountContext
+
+private final class VoiceCallDataSavingControllerArguments {
+    let updateSelection: (VoiceCallDataSaving) -> Void
+    
+    init(updateSelection: @escaping (VoiceCallDataSaving) -> Void) {
+        self.updateSelection = updateSelection
+    }
+}
+
+private enum VoiceCallDataSavingSection: Int32 {
+    case dataSaving
+}
+
+private enum VoiceCallDataSavingEntry: ItemListNodeEntry {
+    case never(PresentationTheme, String, Bool)
+    case cellular(PresentationTheme, String, Bool)
+    case always(PresentationTheme, String, Bool)
+    case info(PresentationTheme, String)
+    
+    var section: ItemListSectionId {
+        return VoiceCallDataSavingSection.dataSaving.rawValue
+    }
+    
+    var stableId: Int32 {
+        switch self {
+            case .never:
+                return 0
+            case .cellular:
+                return 1
+            case .always:
+                return 2
+            case .info:
+                return 3
+        }
+    }
+    
+    static func ==(lhs: VoiceCallDataSavingEntry, rhs: VoiceCallDataSavingEntry) -> Bool {
+        switch lhs {
+            case let .never(lhsTheme, lhsText, lhsValue):
+                if case let .never(rhsTheme, rhsText, rhsValue) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue {
+                    return true
+                } else {
+                    return false
+                }
+            case let .cellular(lhsTheme, lhsText, lhsValue):
+                if case let .cellular(rhsTheme, rhsText, rhsValue) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue {
+                    return true
+                } else {
+                    return false
+                }
+            case let .always(lhsTheme, lhsText, lhsValue):
+                if case let .always(rhsTheme, rhsText, rhsValue) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue {
+                    return true
+                } else {
+                    return false
+                }
+            case let .info(lhsTheme, lhsText):
+                if case let .info(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+        }
+    }
+    
+    static func <(lhs: VoiceCallDataSavingEntry, rhs: VoiceCallDataSavingEntry) -> Bool {
+        return lhs.stableId < rhs.stableId
+    }
+    
+    func item(presentationData: ItemListPresentationData, arguments: Any) -> ListViewItem {
+        let arguments = arguments as! VoiceCallDataSavingControllerArguments
+        switch self {
+            case let .never(_, text, value):
+                return ItemListCheckboxItem(presentationData: presentationData, systemStyle: .glass, title: text, style: .left, checked: value, zeroSeparatorInsets: false, sectionId: self.section, action: {
+                    arguments.updateSelection(.never)
+                })
+            case let .cellular(_, text, value):
+                return ItemListCheckboxItem(presentationData: presentationData, systemStyle: .glass, title: text, style: .left, checked: value, zeroSeparatorInsets: false, sectionId: self.section, action: {
+                    arguments.updateSelection(.cellular)
+                })
+            case let .always(_, text, value):
+                return ItemListCheckboxItem(presentationData: presentationData, systemStyle: .glass, title: text, style: .left, checked: value, zeroSeparatorInsets: false, sectionId: self.section, action: {
+                    arguments.updateSelection(.always)
+                })
+            case let .info(_, text):
+                return ItemListTextItem(presentationData: presentationData, text: .plain(text), sectionId: self.section)
+        }
+    }
+}
+
+private func stringForDataSavingOption(_ option: VoiceCallDataSaving, strings: PresentationStrings) -> String {
+    switch option {
+        case .never:
+            return strings.CallSettings_Never
+        case .cellular:
+            return strings.CallSettings_OnMobile
+        case .always:
+            return strings.CallSettings_Always
+        default:
+            return ""
+    }
+}
+
+private func voiceCallDataSavingControllerEntries(presentationData: PresentationData, dataSaving: VoiceCallDataSaving) -> [VoiceCallDataSavingEntry] {
+    var entries: [VoiceCallDataSavingEntry] = []
+    entries.append(.never(presentationData.theme, stringForDataSavingOption(.never, strings: presentationData.strings), dataSaving == .never))
+    entries.append(.cellular(presentationData.theme, stringForDataSavingOption(.cellular, strings: presentationData.strings), dataSaving == .cellular))
+    entries.append(.always(presentationData.theme, stringForDataSavingOption(.always, strings: presentationData.strings), dataSaving == .always))
+    entries.append(.info(presentationData.theme, presentationData.strings.CallSettings_UseLessDataLongDescription))
+    return entries
+}
+
+func voiceCallDataSavingController(context: AccountContext) -> ViewController {
+    let sharedSettings = context.sharedContext.accountManager.sharedData(keys: [ApplicationSpecificSharedDataKeys.voiceCallSettings])
+    |> map { sharedData -> (VoiceCallSettings, AutodownloadSettings) in
+        let voiceCallSettings: VoiceCallSettings
+        if let value = sharedData.entries[ApplicationSpecificSharedDataKeys.voiceCallSettings]?.get(VoiceCallSettings.self) {
+            voiceCallSettings = value
+        } else {
+            voiceCallSettings = VoiceCallSettings.defaultSettings
+        }
+        
+        let autodownloadSettings: AutodownloadSettings
+        if let value = sharedData.entries[SharedDataKeys.autodownloadSettings]?.get(AutodownloadSettings.self) {
+            autodownloadSettings = value
+        } else {
+            autodownloadSettings = AutodownloadSettings.defaultSettings
+        }
+        
+        return (voiceCallSettings, autodownloadSettings)
+    }
+    
+    let arguments = VoiceCallDataSavingControllerArguments(updateSelection: { option in
+        let _ = updateVoiceCallSettingsSettingsInteractively(accountManager: context.sharedContext.accountManager, { current in
+            var current = current
+            current.dataSaving = option
+            return current
+        }).start()
+    })
+    
+    let signal = combineLatest(context.sharedContext.presentationData, sharedSettings) |> deliverOnMainQueue
+        |> map { presentationData, sharedSettings -> (ItemListControllerState, (ItemListNodeState, Any)) in
+            
+            let dataSaving = effectiveDataSaving(for: sharedSettings.0, autodownloadSettings: sharedSettings.1)
+            
+            let controllerState = ItemListControllerState(presentationData: ItemListPresentationData(presentationData), title: .text(presentationData.strings.CallSettings_Title), leftNavigationButton: nil, rightNavigationButton: nil, backNavigationButton: ItemListBackButton(title: presentationData.strings.Common_Back), animateChanges: false)
+            let listState = ItemListNodeState(presentationData: ItemListPresentationData(presentationData), entries: voiceCallDataSavingControllerEntries(presentationData: presentationData, dataSaving: dataSaving), style: .blocks, emptyStateItem: nil, animateChanges: false)
+            
+            return (controllerState, (listState, arguments))
+        }
+    
+    let controller = ItemListController(context: context, state: signal)
+    return controller
+}

submodules/SettingsUI/Sources/Data and Storage/WebBrowserDomainController.swift

@@ -0,0 +1,471 @@
+import Foundation
+import UIKit
+import SwiftSignalKit
+import AsyncDisplayKit
+import Display
+import TelegramCore
+import TelegramPresentationData
+import AccountContext
+import UrlEscaping
+import ActivityIndicator
+
+private final class WebBrowserDomainInputFieldNode: ASDisplayNode, ASEditableTextNodeDelegate {
+    private var theme: PresentationTheme
+    private let backgroundNode: ASImageNode
+    fileprivate let textInputNode: EditableTextNode
+    private let placeholderNode: ASTextNode
+    
+    var updateHeight: (() -> Void)?
+    var complete: (() -> Void)?
+    var textChanged: ((String) -> Void)?
+    
+    private let backgroundInsets = UIEdgeInsets(top: 8.0, left: 16.0, bottom: 15.0, right: 16.0)
+    private let inputInsets = UIEdgeInsets(top: 5.0, left: 12.0, bottom: 5.0, right: 12.0)
+    
+    var text: String {
+        get {
+            return self.textInputNode.attributedText?.string ?? ""
+        }
+        set {
+            self.textInputNode.attributedText = NSAttributedString(string: newValue, font: Font.regular(17.0), textColor: self.theme.actionSheet.inputTextColor)
+            self.placeholderNode.isHidden = !newValue.isEmpty
+        }
+    }
+    
+    var placeholder: String = "" {
+        didSet {
+            self.placeholderNode.attributedText = NSAttributedString(string: self.placeholder, font: Font.regular(17.0), textColor: self.theme.actionSheet.inputPlaceholderColor)
+        }
+    }
+    
+    init(theme: PresentationTheme, placeholder: String) {
+        self.theme = theme
+        
+        self.backgroundNode = ASImageNode()
+        self.backgroundNode.isLayerBacked = true
+        self.backgroundNode.displaysAsynchronously = false
+        self.backgroundNode.displayWithoutProcessing = true
+        self.backgroundNode.image = generateStretchableFilledCircleImage(diameter: 12.0, color: theme.actionSheet.inputHollowBackgroundColor, strokeColor: theme.actionSheet.inputBorderColor, strokeWidth: 1.0)
+        
+        self.textInputNode = EditableTextNode()
+        self.textInputNode.typingAttributes = [NSAttributedString.Key.font.rawValue: Font.regular(17.0), NSAttributedString.Key.foregroundColor.rawValue: theme.actionSheet.inputTextColor]
+        self.textInputNode.clipsToBounds = true
+        self.textInputNode.hitTestSlop = UIEdgeInsets(top: -5.0, left: -5.0, bottom: -5.0, right: -5.0)
+        self.textInputNode.textContainerInset = UIEdgeInsets(top: self.inputInsets.top, left: 0.0, bottom: self.inputInsets.bottom, right: 0.0)
+        self.textInputNode.keyboardAppearance = theme.rootController.keyboardColor.keyboardAppearance
+        self.textInputNode.keyboardType = .URL
+        self.textInputNode.autocapitalizationType = .none
+        self.textInputNode.returnKeyType = .done
+        self.textInputNode.autocorrectionType = .no
+        self.textInputNode.tintColor = theme.actionSheet.controlAccentColor
+        
+        self.placeholderNode = ASTextNode()
+        self.placeholderNode.isUserInteractionEnabled = false
+        self.placeholderNode.displaysAsynchronously = false
+        self.placeholderNode.attributedText = NSAttributedString(string: placeholder, font: Font.regular(17.0), textColor: self.theme.actionSheet.inputPlaceholderColor)
+        
+        super.init()
+        
+        self.textInputNode.delegate = self
+        
+        self.addSubnode(self.backgroundNode)
+        self.addSubnode(self.textInputNode)
+        self.addSubnode(self.placeholderNode)
+    }
+    
+    func updateTheme(_ theme: PresentationTheme) {
+        self.theme = theme
+        
+        self.backgroundNode.image = generateStretchableFilledCircleImage(diameter: 12.0, color: self.theme.actionSheet.inputHollowBackgroundColor, strokeColor: self.theme.actionSheet.inputBorderColor, strokeWidth: 1.0)
+        self.textInputNode.keyboardAppearance = self.theme.rootController.keyboardColor.keyboardAppearance
+        self.placeholderNode.attributedText = NSAttributedString(string: self.placeholderNode.attributedText?.string ?? "", font: Font.regular(17.0), textColor: self.theme.actionSheet.inputPlaceholderColor)
+        self.textInputNode.tintColor = self.theme.actionSheet.controlAccentColor
+    }
+    
+    func updateLayout(width: CGFloat, transition: ContainedViewLayoutTransition) -> CGFloat {
+        let backgroundInsets = self.backgroundInsets
+        let inputInsets = self.inputInsets
+        
+        let textFieldHeight = self.calculateTextFieldMetrics(width: width)
+        let panelHeight = textFieldHeight + backgroundInsets.top + backgroundInsets.bottom
+        
+        let backgroundFrame = CGRect(origin: CGPoint(x: backgroundInsets.left, y: backgroundInsets.top), size: CGSize(width: width - backgroundInsets.left - backgroundInsets.right, height: panelHeight - backgroundInsets.top - backgroundInsets.bottom))
+        transition.updateFrame(node: self.backgroundNode, frame: backgroundFrame)
+        
+        let placeholderSize = self.placeholderNode.measure(backgroundFrame.size)
+        transition.updateFrame(node: self.placeholderNode, frame: CGRect(origin: CGPoint(x: backgroundFrame.minX + inputInsets.left, y: backgroundFrame.minY + floor((backgroundFrame.size.height - placeholderSize.height) / 2.0)), size: placeholderSize))
+        
+        transition.updateFrame(node: self.textInputNode, frame: CGRect(origin: CGPoint(x: backgroundFrame.minX + inputInsets.left, y: backgroundFrame.minY), size: CGSize(width: backgroundFrame.size.width - inputInsets.left - inputInsets.right, height: backgroundFrame.size.height)))
+        
+        return panelHeight
+    }
+    
+    func activateInput() {
+        self.textInputNode.becomeFirstResponder()
+    }
+    
+    func deactivateInput() {
+        self.textInputNode.resignFirstResponder()
+    }
+    
+    @objc func editableTextNodeDidUpdateText(_ editableTextNode: ASEditableTextNode) {
+        self.updateTextNodeText(animated: true)
+        self.textChanged?(editableTextNode.textView.text)
+        self.placeholderNode.isHidden = !(editableTextNode.textView.text ?? "").isEmpty
+    }
+    
+    private let domainRegex = try? NSRegularExpression(pattern: "^(https?://)?([a-zA-Z0-9-]+\\.?)*([a-zA-Z]*)?(:)?(/)?$", options: [])
+    private let pathRegex = try? NSRegularExpression(pattern: "^(https?://)?([a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,6}/", options: [])
+    
+    var inProgress = false
+    
+    func editableTextNode(_ editableTextNode: ASEditableTextNode, shouldChangeTextIn range: NSRange, replacementText text: String) -> Bool {
+        if self.inProgress {
+            return false
+        }
+        if text == "\n" {
+            self.complete?()
+            return false
+        }
+        
+        if let domainRegex = self.domainRegex, let pathRegex = self.pathRegex {
+            let updatedText = (editableTextNode.textView.text as NSString).replacingCharacters(in: range, with: text)
+            let domainMatches = domainRegex.matches(in: updatedText, options: [], range: NSRange(location: 0, length: updatedText.utf16.count))
+            let pathMatches = pathRegex.matches(in: updatedText, options: [], range: NSRange(location: 0, length: updatedText.utf16.count))
+                 
+            if domainMatches.count > 0, pathMatches.count == 0 {
+                return true
+            } else {
+                return false
+            }
+        }
+        
+        return true
+    }
+    
+    private func calculateTextFieldMetrics(width: CGFloat) -> CGFloat {
+        let backgroundInsets = self.backgroundInsets
+        let inputInsets = self.inputInsets
+        
+        let unboundTextFieldHeight = max(33.0, ceil(self.textInputNode.measure(CGSize(width: width - backgroundInsets.left - backgroundInsets.right - inputInsets.left - inputInsets.right, height: CGFloat.greatestFiniteMagnitude)).height))
+        
+        return min(61.0, max(33.0, unboundTextFieldHeight))
+    }
+    
+    private func updateTextNodeText(animated: Bool) {
+        let backgroundInsets = self.backgroundInsets
+        
+        let textFieldHeight = self.calculateTextFieldMetrics(width: self.bounds.size.width)
+        
+        let panelHeight = textFieldHeight + backgroundInsets.top + backgroundInsets.bottom
+        if !self.bounds.size.height.isEqual(to: panelHeight) {
+            self.updateHeight?()
+        }
+    }
+    
+    @objc func clearPressed() {
+        self.textInputNode.attributedText = nil
+        self.deactivateInput()
+    }
+}
+
+private final class WebBrowserDomainAlertContentNode: AlertContentNode {
+    private let strings: PresentationStrings
+    
+    private let titleNode: ASTextNode
+    private let textNode: ASTextNode
+    let activityIndicator: ActivityIndicator
+    let inputFieldNode: WebBrowserDomainInputFieldNode
+    
+    private let actionNodesSeparator: ASDisplayNode
+    private let actionNodes: [TextAlertContentActionNode]
+    private let actionVerticalSeparators: [ASDisplayNode]
+    
+    private let disposable = MetaDisposable()
+    
+    private var validLayout: CGSize?
+    
+    private let hapticFeedback = HapticFeedback()
+    
+    var complete: (() -> Void)? {
+        didSet {
+            self.inputFieldNode.complete = self.complete
+        }
+    }
+    
+    override var dismissOnOutsideTap: Bool {
+        return self.isUserInteractionEnabled
+    }
+        
+    init(theme: AlertControllerTheme, ptheme: PresentationTheme, strings: PresentationStrings, actions: [TextAlertAction]) {
+        self.strings = strings
+        
+        self.titleNode = ASTextNode()
+        self.titleNode.maximumNumberOfLines = 2
+        self.textNode = ASTextNode()
+        self.textNode.maximumNumberOfLines = 2
+        
+        self.activityIndicator = ActivityIndicator(type: .custom(ptheme.rootController.navigationBar.secondaryTextColor, 20.0, 1.5, false), speed: .slow)
+        self.activityIndicator.isHidden = true
+        
+        self.inputFieldNode = WebBrowserDomainInputFieldNode(theme: ptheme, placeholder: strings.WebBrowser_Exceptions_Create_Placeholder)
+        self.inputFieldNode.text = ""
+        
+        self.actionNodesSeparator = ASDisplayNode()
+        self.actionNodesSeparator.isLayerBacked = true
+        
+        self.actionNodes = actions.map { action -> TextAlertContentActionNode in
+            return TextAlertContentActionNode(theme: theme, action: action)
+        }
+        
+        var actionVerticalSeparators: [ASDisplayNode] = []
+        if actions.count > 1 {
+            for _ in 0 ..< actions.count - 1 {
+                let separatorNode = ASDisplayNode()
+                separatorNode.isLayerBacked = true
+                actionVerticalSeparators.append(separatorNode)
+            }
+        }
+        self.actionVerticalSeparators = actionVerticalSeparators
+        
+        super.init()
+        
+        self.addSubnode(self.titleNode)
+        self.addSubnode(self.textNode)
+        
+        self.addSubnode(self.inputFieldNode)
+        self.addSubnode(self.activityIndicator)
+        
+        self.addSubnode(self.actionNodesSeparator)
+        
+        for actionNode in self.actionNodes {
+            self.addSubnode(actionNode)
+        }
+        self.actionNodes.last?.actionEnabled = false
+        
+        for separatorNode in self.actionVerticalSeparators {
+            self.addSubnode(separatorNode)
+        }
+        
+        self.inputFieldNode.updateHeight = { [weak self] in
+            if let strongSelf = self {
+                if let _ = strongSelf.validLayout {
+                    strongSelf.requestLayout?(.animated(duration: 0.15, curve: .spring))
+                }
+            }
+        }
+        
+        self.inputFieldNode.textChanged = { [weak self] text in
+            if let strongSelf = self, let lastNode = strongSelf.actionNodes.last {
+                lastNode.actionEnabled = !text.isEmpty
+            }
+        }
+        
+        self.updateTheme(theme)
+    }
+    
+    deinit {
+        self.disposable.dispose()
+    }
+    
+    var link: String {
+        return self.inputFieldNode.text
+    }
+
+    override func updateTheme(_ theme: AlertControllerTheme) {
+        self.titleNode.attributedText = NSAttributedString(string: self.strings.WebBrowser_Exceptions_Create_Title, font: Font.bold(17.0), textColor: theme.primaryColor, paragraphAlignment: .center)
+        self.textNode.attributedText = NSAttributedString(string: self.strings.WebBrowser_Exceptions_Create_Text, font: Font.regular(13.0), textColor: theme.primaryColor, paragraphAlignment: .center)
+
+        self.actionNodesSeparator.backgroundColor = theme.separatorColor
+        for actionNode in self.actionNodes {
+            actionNode.updateTheme(theme)
+        }
+        for separatorNode in self.actionVerticalSeparators {
+            separatorNode.backgroundColor = theme.separatorColor
+        }
+        
+        if let size = self.validLayout {
+            _ = self.updateLayout(size: size, transition: .immediate)
+        }
+    }
+    
+    override func updateLayout(size: CGSize, transition: ContainedViewLayoutTransition) -> CGSize {
+        var size = size
+        size.width = min(size.width, 270.0)
+        let measureSize = CGSize(width: size.width - 16.0 * 2.0, height: CGFloat.greatestFiniteMagnitude)
+        
+        let hadValidLayout = self.validLayout != nil
+        
+        self.validLayout = size
+        
+        var origin: CGPoint = CGPoint(x: 0.0, y: 20.0)
+        let spacing: CGFloat = 5.0
+        
+        let titleSize = self.titleNode.measure(measureSize)
+        transition.updateFrame(node: self.titleNode, frame: CGRect(origin: CGPoint(x: floorToScreenPixels((size.width - titleSize.width) / 2.0), y: origin.y), size: titleSize))
+        origin.y += titleSize.height + 4.0
+        
+        let textSize = self.textNode.measure(measureSize)
+        transition.updateFrame(node: self.textNode, frame: CGRect(origin: CGPoint(x: floorToScreenPixels((size.width - textSize.width) / 2.0), y: origin.y), size: textSize))
+        origin.y += textSize.height + 6.0 + spacing
+        
+        let actionButtonHeight: CGFloat = 44.0
+        var minActionsWidth: CGFloat = 0.0
+        let maxActionWidth: CGFloat = floor(size.width / CGFloat(self.actionNodes.count))
+        let actionTitleInsets: CGFloat = 8.0
+        
+        var effectiveActionLayout = TextAlertContentActionLayout.horizontal
+        for actionNode in self.actionNodes {
+            let actionTitleSize = actionNode.titleNode.updateLayout(CGSize(width: maxActionWidth, height: actionButtonHeight))
+            if case .horizontal = effectiveActionLayout, actionTitleSize.height > actionButtonHeight * 0.6667 {
+                effectiveActionLayout = .vertical
+            }
+            switch effectiveActionLayout {
+                case .horizontal:
+                    minActionsWidth += actionTitleSize.width + actionTitleInsets
+                case .vertical:
+                    minActionsWidth = max(minActionsWidth, actionTitleSize.width + actionTitleInsets)
+            }
+        }
+        
+        let insets = UIEdgeInsets(top: 18.0, left: 18.0, bottom: 9.0, right: 18.0)
+        
+        var contentWidth = max(titleSize.width, minActionsWidth)
+        contentWidth = max(contentWidth, 234.0)
+        
+        var actionsHeight: CGFloat = 0.0
+        switch effectiveActionLayout {
+            case .horizontal:
+                actionsHeight = actionButtonHeight
+            case .vertical:
+                actionsHeight = actionButtonHeight * CGFloat(self.actionNodes.count)
+        }
+        
+        let resultWidth = contentWidth + insets.left + insets.right
+        
+        let inputFieldWidth = resultWidth
+        let inputFieldHeight = self.inputFieldNode.updateLayout(width: inputFieldWidth, transition: transition)
+        let inputHeight = inputFieldHeight
+        let inputFrame = CGRect(x: 0.0, y: origin.y, width: resultWidth, height: inputFieldHeight)
+        transition.updateFrame(node: self.inputFieldNode, frame: inputFrame)
+        transition.updateAlpha(node: self.inputFieldNode, alpha: inputHeight > 0.0 ? 1.0 : 0.0)
+        
+        let activitySize = CGSize(width: 20.0, height: 20.0)
+        transition.updateFrame(node: self.activityIndicator, frame: CGRect(origin: CGPoint(x: inputFrame.maxX - activitySize.width - 23.0, y: inputFrame.midY - activitySize.height / 2.0 - 3.0), size: activitySize))
+        
+        let resultSize = CGSize(width: resultWidth, height: titleSize.height + textSize.height + spacing + inputHeight + actionsHeight  + insets.top + insets.bottom)
+        
+        transition.updateFrame(node: self.actionNodesSeparator, frame: CGRect(origin: CGPoint(x: 0.0, y: resultSize.height - actionsHeight - UIScreenPixel), size: CGSize(width: resultSize.width, height: UIScreenPixel)))
+        
+        var actionOffset: CGFloat = 0.0
+        let actionWidth: CGFloat = floor(resultSize.width / CGFloat(self.actionNodes.count))
+        var separatorIndex = -1
+        var nodeIndex = 0
+        for actionNode in self.actionNodes {
+            if separatorIndex >= 0 {
+                let separatorNode = self.actionVerticalSeparators[separatorIndex]
+                switch effectiveActionLayout {
+                    case .horizontal:
+                        transition.updateFrame(node: separatorNode, frame: CGRect(origin: CGPoint(x: actionOffset - UIScreenPixel, y: resultSize.height - actionsHeight), size: CGSize(width: UIScreenPixel, height: actionsHeight - UIScreenPixel)))
+                    case .vertical:
+                        transition.updateFrame(node: separatorNode, frame: CGRect(origin: CGPoint(x: 0.0, y: resultSize.height - actionsHeight + actionOffset - UIScreenPixel), size: CGSize(width: resultSize.width, height: UIScreenPixel)))
+                }
+            }
+            separatorIndex += 1
+            
+            let currentActionWidth: CGFloat
+            switch effectiveActionLayout {
+                case .horizontal:
+                    if nodeIndex == self.actionNodes.count - 1 {
+                        currentActionWidth = resultSize.width - actionOffset
+                    } else {
+                        currentActionWidth = actionWidth
+                    }
+                case .vertical:
+                    currentActionWidth = resultSize.width
+            }
+            
+            let actionNodeFrame: CGRect
+            switch effectiveActionLayout {
+                case .horizontal:
+                    actionNodeFrame = CGRect(origin: CGPoint(x: actionOffset, y: resultSize.height - actionsHeight), size: CGSize(width: currentActionWidth, height: actionButtonHeight))
+                    actionOffset += currentActionWidth
+                case .vertical:
+                    actionNodeFrame = CGRect(origin: CGPoint(x: 0.0, y: resultSize.height - actionsHeight + actionOffset), size: CGSize(width: currentActionWidth, height: actionButtonHeight))
+                    actionOffset += actionButtonHeight
+            }
+            
+            transition.updateFrame(node: actionNode, frame: actionNodeFrame)
+            
+            nodeIndex += 1
+        }
+        
+        if !hadValidLayout {
+            self.inputFieldNode.activateInput()
+        }
+        
+        return resultSize
+    }
+    
+    func animateError() {
+        self.inputFieldNode.layer.addShakeAnimation()
+        self.hapticFeedback.error()
+    }
+}
+
+public func webBrowserDomainController(context: AccountContext, updatedPresentationData: (initial: PresentationData, signal: Signal<PresentationData, NoError>)? = nil, apply: @escaping (String?) -> Void) -> AlertController {
+    let presentationData = updatedPresentationData?.initial ?? context.sharedContext.currentPresentationData.with { $0 }
+    
+    var dismissImpl: ((Bool) -> Void)?
+    var applyImpl: (() -> Void)?
+    
+    var inProgress = false
+    let actions: [TextAlertAction] = [TextAlertAction(type: .genericAction, title: presentationData.strings.Common_Cancel, action: {
+        if !inProgress {
+            dismissImpl?(true)
+            apply(nil)
+        }
+    }), TextAlertAction(type: .defaultAction, title: presentationData.strings.Common_Done, action: {
+        if !inProgress {
+            applyImpl?()
+        }
+    })]
+    
+    let contentNode = WebBrowserDomainAlertContentNode(theme: AlertControllerTheme(presentationData: presentationData), ptheme: presentationData.theme, strings: presentationData.strings, actions: actions)
+    contentNode.complete = {
+        applyImpl?()
+    }
+    applyImpl = { [weak contentNode] in
+        guard let contentNode = contentNode else {
+            return
+        }
+        inProgress = true
+        contentNode.inputFieldNode.inProgress = true
+        contentNode.activityIndicator.isHidden = false
+        
+        let updatedLink = explicitUrl(contentNode.link)
+        if !updatedLink.isEmpty && isValidUrl(updatedLink, validSchemes: ["http": true, "https": true]) {
+            apply(updatedLink)
+        } else {
+            contentNode.animateError()
+        }
+    }
+    
+    let controller = AlertController(theme: AlertControllerTheme(presentationData: presentationData), contentNode: contentNode)
+    let presentationDataDisposable = (updatedPresentationData?.signal ?? context.sharedContext.presentationData).start(next: { [weak controller, weak contentNode] presentationData in
+        controller?.theme = AlertControllerTheme(presentationData: presentationData)
+        contentNode?.inputFieldNode.updateTheme(presentationData.theme)
+    })
+    controller.dismissed = { _ in
+        presentationDataDisposable.dispose()
+    }
+    dismissImpl = { [weak controller] animated in
+        contentNode.inputFieldNode.deactivateInput()
+        if animated {
+            controller?.dismissAnimated()
+        } else {
+            controller?.dismiss()
+        }
+    }
+    return controller
+}

submodules/SettingsUI/Sources/Data and Storage/WebBrowserDomainExceptionItem.swift

@@ -0,0 +1,358 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import TelegramPresentationData
+import TelegramCore
+import AccountContext
+import ItemListUI
+import PhotoResources
+
+private enum RevealOptionKey: Int32 {
+    case delete
+}
+
+final class WebBrowserDomainExceptionItem: ListViewItem, ItemListItem {
+    let presentationData: ItemListPresentationData
+    let systemStyle: ItemListSystemStyle
+    let context: AccountContext
+    let title: String
+    let label: String
+    let icon: TelegramMediaImage?
+    let sectionId: ItemListSectionId
+    let style: ItemListStyle
+    let deleted: (() -> Void)?
+    
+    init(
+        presentationData: ItemListPresentationData,
+        systemStyle: ItemListSystemStyle,
+        context: AccountContext,
+        title: String,
+        label: String,
+        icon: TelegramMediaImage?,
+        sectionId: ItemListSectionId,
+        style: ItemListStyle,
+        deleted: (() -> Void)?
+    ) {
+        self.presentationData = presentationData
+        self.systemStyle = systemStyle
+        self.context = context
+        self.title = title
+        self.label = label
+        self.icon = icon
+        self.sectionId = sectionId
+        self.style = style
+        self.deleted = deleted
+    }
+    
+    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 = WebBrowserDomainExceptionItemNode()
+            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 {
+            if let nodeValue = node() as? WebBrowserDomainExceptionItemNode {
+                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()
+                        })
+                    }
+                }
+            }
+        }
+    }
+    
+    var selectable: Bool = false
+    
+    func selected(listView: ListView){
+    }
+}
+
+final class WebBrowserDomainExceptionItemNode: ItemListRevealOptionsItemNode, ItemListItemNode {
+    private let backgroundNode: ASDisplayNode
+    private let topStripeNode: ASDisplayNode
+    private let bottomStripeNode: ASDisplayNode
+    private let maskNode: ASImageNode
+    
+    let iconNode: TransformImageNode
+    let titleNode: TextNode
+    let labelNode: TextNode
+    
+    private let activateArea: AccessibilityAreaNode
+    
+    private var item: WebBrowserDomainExceptionItem?
+    private var layoutParams: ListViewItemLayoutParams?
+    
+    override public var canBeSelected: Bool {
+        return false
+    }
+    
+    var tag: ItemListItemTag? = nil
+    
+    init() {
+        self.backgroundNode = ASDisplayNode()
+        self.backgroundNode.isLayerBacked = true
+        self.backgroundNode.backgroundColor = .white
+        
+        self.maskNode = ASImageNode()
+        self.maskNode.isUserInteractionEnabled = false
+        
+        self.topStripeNode = ASDisplayNode()
+        self.topStripeNode.isLayerBacked = true
+        
+        self.bottomStripeNode = ASDisplayNode()
+        self.bottomStripeNode.isLayerBacked = true
+        
+        self.iconNode = TransformImageNode()
+        self.iconNode.isLayerBacked = true
+        self.iconNode.displaysAsynchronously = false
+        
+        self.titleNode = TextNode()
+        self.titleNode.isUserInteractionEnabled = false
+        
+        self.labelNode = TextNode()
+        self.labelNode.isUserInteractionEnabled = false
+        
+        self.activateArea = AccessibilityAreaNode()
+        
+        super.init(layerBacked: false, dynamicBounce: false, rotated: false, seeThrough: false)
+        
+        self.addSubnode(self.iconNode)
+        self.addSubnode(self.titleNode)
+        self.addSubnode(self.labelNode)
+        
+        self.addSubnode(self.activateArea)
+    }
+
+    func asyncLayout() -> (_ item: WebBrowserDomainExceptionItem, _ params: ListViewItemLayoutParams, _ insets: ItemListNeighbors) -> (ListViewItemNodeLayout, () -> Void) {
+        let makeTitleLayout = TextNode.asyncLayout(self.titleNode)
+        let makeLabelLayout = TextNode.asyncLayout(self.labelNode)
+                      
+        let currentItem = self.item
+        
+        return { item, params, neighbors in
+            var updatedTheme: PresentationTheme?
+            if currentItem?.presentationData.theme !== item.presentationData.theme {
+                updatedTheme = item.presentationData.theme
+            }
+            
+            let contentSize: CGSize
+            let insets: UIEdgeInsets
+            let separatorHeight = UIScreenPixel
+            let separatorRightInset: CGFloat = item.systemStyle == .glass ? 16.0 : 0.0
+            
+            let itemBackgroundColor: UIColor
+            let itemSeparatorColor: UIColor
+            
+            let leftInset = 16.0 + params.leftInset + 46.0
+            
+            let titleColor: UIColor = item.presentationData.theme.list.itemPrimaryTextColor
+            let labelColor: UIColor = item.presentationData.theme.list.itemAccentColor
+            
+            let titleFont = Font.medium(item.presentationData.fontSize.itemListBaseFontSize)
+            let labelFont = Font.regular(floor(item.presentationData.fontSize.itemListBaseFontSize * 15.0 / 17.0))
+            
+            let maxTitleWidth: CGFloat = params.width - params.rightInset - 20.0 - leftInset
+            
+            let (titleLayout, titleApply) = makeTitleLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: item.title, font: titleFont, textColor: titleColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: maxTitleWidth, height: CGFloat.greatestFiniteMagnitude), alignment: .natural, cutout: nil, insets: UIEdgeInsets()))
+            
+            let (labelLayout, labelApply) = makeLabelLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: item.label, font: labelFont, textColor: labelColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: maxTitleWidth, height: CGFloat.greatestFiniteMagnitude), alignment: .natural, cutout: nil, insets: UIEdgeInsets()))
+            
+            let verticalInset: CGFloat
+            switch item.systemStyle {
+            case .glass:
+                verticalInset = 11.0
+            case .legacy:
+                verticalInset = 11.0
+            }
+            let titleSpacing: CGFloat = 1.0
+            
+            let height: CGFloat = verticalInset * 2.0 + titleLayout.size.height + titleSpacing + labelLayout.size.height
+    
+            switch item.style {
+            case .plain:
+                itemBackgroundColor = item.presentationData.theme.list.plainBackgroundColor
+                itemSeparatorColor = item.presentationData.theme.list.itemPlainSeparatorColor
+                contentSize = CGSize(width: params.width, height: height)
+                insets = itemListNeighborsPlainInsets(neighbors)
+            case .blocks:
+                itemBackgroundColor = item.presentationData.theme.list.itemBlocksBackgroundColor
+                itemSeparatorColor = item.presentationData.theme.list.itemBlocksSeparatorColor
+                contentSize = CGSize(width: params.width, height: height)
+                insets = itemListNeighborsGroupedInsets(neighbors, params)
+            }
+            
+            let layout = ListViewItemNodeLayout(contentSize: contentSize, insets: insets)
+            
+            return (ListViewItemNodeLayout(contentSize: contentSize, insets: insets), { [weak self] in
+                if let strongSelf = self {
+                    strongSelf.item = item
+                    strongSelf.layoutParams = params
+                    
+                    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 = item.title
+                    strongSelf.activateArea.accessibilityValue = item.label
+                    
+                    if let _ = updatedTheme {
+                        strongSelf.topStripeNode.backgroundColor = itemSeparatorColor
+                        strongSelf.bottomStripeNode.backgroundColor = itemSeparatorColor
+                        strongSelf.backgroundNode.backgroundColor = itemBackgroundColor
+                    }
+                    
+                    let iconSize = CGSize(width: 40.0, height: 40.0)
+                    var imageSize = iconSize
+                    if currentItem?.icon?.id != item.icon?.id, let icon = item.icon {
+                        strongSelf.iconNode.setSignal(chatMessagePhoto(mediaBox: item.context.sharedContext.accountManager.mediaBox, userLocation: .other, photoReference: .standalone(media: icon)))
+                    }
+                    if let icon = item.icon, let dimensions = largestImageRepresentation(icon.representations)?.dimensions.cgSize {
+                        imageSize = dimensions.aspectFilled(imageSize)
+                    }
+                    
+                    let _ = titleApply()
+                    let _ = labelApply()
+                    
+                    switch item.style {
+                    case .plain:
+                        if strongSelf.backgroundNode.supernode != nil {
+                            strongSelf.backgroundNode.removeFromSupernode()
+                        }
+                        if strongSelf.topStripeNode.supernode != nil {
+                            strongSelf.topStripeNode.removeFromSupernode()
+                        }
+                        if strongSelf.bottomStripeNode.supernode == nil {
+                            strongSelf.insertSubnode(strongSelf.bottomStripeNode, at: 0)
+                        }
+                        if strongSelf.maskNode.supernode != nil {
+                            strongSelf.maskNode.removeFromSupernode()
+                        }
+                        strongSelf.bottomStripeNode.frame = CGRect(origin: CGPoint(x: leftInset, y: contentSize.height - separatorHeight), size: CGSize(width: params.width - leftInset, height: separatorHeight))
+                    case .blocks:
+                        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.insertSubnode(strongSelf.maskNode, at: 3)
+                        }
+                        
+                        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
+                        switch neighbors.bottom {
+                            case .sameSection(false):
+                                bottomStripeInset = leftInset
+                                strongSelf.bottomStripeNode.isHidden = false
+                            default:
+                                bottomStripeInset = 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.maskNode.frame = strongSelf.backgroundNode.frame.insetBy(dx: params.leftInset, dy: 0.0)
+                        strongSelf.topStripeNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: params.width, height: separatorHeight))
+                        strongSelf.bottomStripeNode.frame = CGRect(origin: CGPoint(x: bottomStripeInset, y: contentSize.height - separatorHeight), size: CGSize(width: params.width - bottomStripeInset - params.rightInset - separatorRightInset, height: separatorHeight))
+                    }
+                    
+                    var centralContentHeight: CGFloat = titleLayout.size.height
+                    centralContentHeight += titleSpacing
+                    centralContentHeight += labelLayout.size.height
+                       
+                    let titleFrame = CGRect(origin: CGPoint(x: leftInset + strongSelf.revealOffset, y: floor((height - centralContentHeight) / 2.0)), size: titleLayout.size)
+                    strongSelf.titleNode.frame = titleFrame
+                    
+                    let labelFrame = CGRect(origin: CGPoint(x: leftInset + strongSelf.revealOffset, y: titleFrame.maxY + titleSpacing), size: labelLayout.size)
+                    strongSelf.labelNode.frame = labelFrame
+                    
+                    let iconFrame = CGRect(origin: CGPoint(x: params.leftInset + 11.0 + strongSelf.revealOffset, y: floorToScreenPixels((contentSize.height - iconSize.height) / 2.0)), size: iconSize)
+                    strongSelf.iconNode.frame = iconFrame
+                    
+                    strongSelf.iconNode.asyncLayout()(TransformImageArguments(corners: ImageCorners(radius: 7.0), imageSize: imageSize, boundingSize: iconSize, intrinsicInsets: .zero))()
+                    
+                    strongSelf.updateLayout(size: layout.contentSize, leftInset: params.leftInset, rightInset: params.rightInset)
+                    
+                    var revealOptions: [ItemListRevealOption] = []
+                    revealOptions.append(ItemListRevealOption(key: RevealOptionKey.delete.rawValue, title: item.presentationData.strings.Common_Delete, icon: .none, color: item.presentationData.theme.list.itemDisclosureActions.destructive.fillColor, textColor: item.presentationData.theme.list.itemDisclosureActions.destructive.foregroundColor))
+                    strongSelf.setRevealOptions((left: [], right: revealOptions))
+                }
+            })
+        }
+    }
+    
+    override func animateInsertion(_ currentTimestamp: Double, duration: Double, options: ListViewItemAnimationOptions) {
+        self.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.4)
+    }
+    
+    override func animateAdded(_ currentTimestamp: Double, duration: Double) {
+        self.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.2)
+    }
+    
+    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)
+        
+        if let params = self.layoutParams {
+            let leftInset: CGFloat = 16.0 + params.leftInset + 46.0
+            
+            var iconFrame = self.iconNode.frame
+            iconFrame.origin.x = params.leftInset + 11.0 + offset
+            transition.updateFrame(node: self.iconNode, frame: iconFrame)
+            
+            var titleFrame = self.titleNode.frame
+            titleFrame.origin.x = leftInset + offset
+            transition.updateFrame(node: self.titleNode, frame: titleFrame)
+            
+            var subtitleFrame = self.labelNode.frame
+            subtitleFrame.origin.x = leftInset + offset
+            transition.updateFrame(node: self.labelNode, frame: subtitleFrame)
+        }
+    }
+    
+    override func revealOptionSelected(_ option: ItemListRevealOption, animated: Bool) {
+        if let item = self.item {
+            switch option.key {
+                case RevealOptionKey.delete.rawValue:
+                    item.deleted?()
+                default:
+                    break
+            }
+        }
+        self.setRevealOptionsOpened(false, animated: true)
+        self.revealOptionsInteractivelyClosed()
+    }
+}

submodules/SettingsUI/Sources/Data and Storage/WebBrowserItem.swift

@@ -0,0 +1,328 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import TelegramCore
+import TelegramPresentationData
+import ItemListUI
+import PhotoResources
+import OpenInExternalAppUI
+import AccountContext
+import AppBundle
+
+class WebBrowserItem: ListViewItem, ItemListItem {
+    let context: AccountContext
+    let presentationData: ItemListPresentationData
+    let systemStyle: ItemListSystemStyle
+    let title: String
+    let application: OpenInApplication?
+    let checked: Bool
+    public let sectionId: ItemListSectionId
+    let action: () -> Void
+    
+    public init(context: AccountContext, presentationData: ItemListPresentationData, systemStyle: ItemListSystemStyle, title: String, application: OpenInApplication?, checked: Bool, sectionId: ItemListSectionId, action: @escaping () -> Void) {
+        self.context = context
+        self.presentationData = presentationData
+        self.systemStyle = systemStyle
+        self.title = title
+        self.application = application
+        self.checked = checked
+        self.sectionId = sectionId
+        self.action = action
+    }
+    
+    public 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 = WebBrowserItemNode()
+            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() })
+                })
+            }
+        }
+    }
+    
+    public 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? WebBrowserItemNode {
+                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()
+                        })
+                    }
+                }
+            }
+        }
+    }
+    
+    public var selectable: Bool = true
+    
+    public func selected(listView: ListView){
+        listView.clearHighlightAnimated(true)
+        self.action()
+    }
+}
+
+private final class WebBrowserItemNode: ListViewItemNode {
+    private let backgroundNode: ASDisplayNode
+    private let topStripeNode: ASDisplayNode
+    private let bottomStripeNode: ASDisplayNode
+    private let highlightedBackgroundNode: ASDisplayNode
+    private let maskNode: ASImageNode
+    
+    private let activateArea: AccessibilityAreaNode
+    
+    private let iconNode: TransformImageNode
+    private let checkIconNode: ASImageNode
+    private let titleNode: TextNode
+    
+    private var item: WebBrowserItem?
+    
+    public 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.checkIconNode = ASImageNode()
+        self.checkIconNode.isLayerBacked = true
+        self.checkIconNode.displayWithoutProcessing = true
+        self.checkIconNode.displaysAsynchronously = false
+        
+        self.iconNode = TransformImageNode()
+        
+        self.titleNode = TextNode()
+        self.titleNode.isUserInteractionEnabled = false
+        self.titleNode.contentMode = .left
+        self.titleNode.contentsScale = UIScreen.main.scale
+        
+        self.highlightedBackgroundNode = ASDisplayNode()
+        self.highlightedBackgroundNode.isLayerBacked = true
+        
+        self.activateArea = AccessibilityAreaNode()
+        
+        super.init(layerBacked: false, dynamicBounce: false)
+        
+        self.addSubnode(self.iconNode)
+        self.addSubnode(self.checkIconNode)
+        self.addSubnode(self.titleNode)
+        self.addSubnode(self.activateArea)
+        
+        self.activateArea.activate = { [weak self] in
+            self?.item?.action()
+            return true
+        }
+    }
+    
+    public func asyncLayout() -> (_ item: WebBrowserItem, _ params: ListViewItemLayoutParams, _ neighbors: ItemListNeighbors) -> (ListViewItemNodeLayout, () -> Void) {
+        let makeTitleLayout = TextNode.asyncLayout(self.titleNode)
+        let makeIconLayout = self.iconNode.asyncLayout()
+        
+        let currentItem = self.item
+
+        
+        return { item, params, neighbors in
+            let leftInset: CGFloat = params.leftInset + 16.0 + 43.0
+            
+            let iconSize = CGSize(width: 29.0, height: 29.0)
+            let arguments = TransformImageArguments(corners: ImageCorners(radius: 5.0), imageSize: iconSize, boundingSize: iconSize, intrinsicInsets: UIEdgeInsets(), emptyColor: item.presentationData.theme.list.mediaPlaceholderColor)
+            let imageApply = makeIconLayout(arguments)
+            
+            var updatedIconSignal: Signal<(TransformImageArguments) -> DrawingContext?, NoError>?
+            if currentItem == nil {
+                switch item.application {
+                case .none:
+                    let icons = item.context.sharedContext.applicationBindings.getAvailableAlternateIcons()
+                    let current = item.context.sharedContext.applicationBindings.getAlternateIconName()
+                    let currentIcon = icons.first(where: { $0.name == current })?.imageName ?? "BlueIcon"
+                    if let image = UIImage(named: currentIcon, in: getAppBundle(), compatibleWith: nil) {
+                        updatedIconSignal = openInAppIcon(engine: item.context.engine, appIcon: .image(image: image))
+                    }
+                case .safari:
+                    if let image = UIImage(bundleImageName: "Open In/Safari") {
+                        updatedIconSignal = openInAppIcon(engine: item.context.engine, appIcon: .image(image: image))
+                    }
+                case .maps:
+                    if let image = UIImage(bundleImageName: "Open In/Maps") {
+                        updatedIconSignal = openInAppIcon(engine: item.context.engine, appIcon: .image(image: image))
+                    }
+                case let .other(_, identifier, _, store):
+                    updatedIconSignal = openInAppIcon(engine: item.context.engine, appIcon: .resource(resource: OpenInAppIconResource(appStoreId: identifier, store: store)))
+                }
+            }
+            
+            let titleFont = Font.regular(item.presentationData.fontSize.itemListBaseFontSize)
+            
+            let (titleLayout, titleApply) = makeTitleLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: item.title, font: titleFont, textColor: item.presentationData.theme.list.itemPrimaryTextColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width - leftInset - 20.0, height: CGFloat.greatestFiniteMagnitude), alignment: .natural, cutout: nil, insets: UIEdgeInsets()))
+            
+            let separatorHeight = UIScreenPixel
+            let separatorRightInset: CGFloat = item.systemStyle == .glass ? 16.0 : 0.0
+            
+            let verticalInset: CGFloat
+            switch item.systemStyle {
+            case .glass:
+                verticalInset = 15.0
+            case .legacy:
+                verticalInset = 11.0
+            }
+            
+            let insets = itemListNeighborsGroupedInsets(neighbors, params)
+            let contentSize = CGSize(width: params.width, height: verticalInset * 2.0 + titleLayout.size.height)
+            
+            let layout = ListViewItemNodeLayout(contentSize: contentSize, insets: insets)
+            
+            var updateCheckImage: UIImage?
+            var updatedTheme: PresentationTheme?
+            
+            if currentItem?.presentationData.theme !== item.presentationData.theme {
+                updatedTheme = item.presentationData.theme
+                updateCheckImage = PresentationResourcesItemList.checkIconImage(item.presentationData.theme)
+            }
+
+            return (layout, { [weak self] in
+                if let strongSelf = self {
+                    strongSelf.item = item
+                    
+                    strongSelf.activateArea.accessibilityLabel = item.title
+                    if item.checked {
+                        strongSelf.activateArea.accessibilityValue = "Selected"
+                    } else {
+                        strongSelf.activateArea.accessibilityValue = ""
+                    }
+                    
+                    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))
+                    
+                    if let updateCheckImage = updateCheckImage {
+                        strongSelf.checkIconNode.image = updateCheckImage
+                    }
+                    
+                    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 _ = titleApply()
+                    let _ = imageApply()
+                    if let updatedImageSignal = updatedIconSignal {
+                        strongSelf.iconNode.setSignal(updatedImageSignal)
+                    }
+                    
+                    strongSelf.iconNode.frame = CGRect(origin: CGPoint(x: params.leftInset + floor((leftInset - params.leftInset - iconSize.width) / 2.0), y: floor((layout.contentSize.height - iconSize.height) / 2.0)), size: iconSize)
+                    
+                    if let image = strongSelf.checkIconNode.image {
+                        strongSelf.checkIconNode.frame = CGRect(origin: CGPoint(x: params.width - params.rightInset - image.size.width - floor((44.0 - image.size.width) / 2.0), y: floor((contentSize.height - image.size.height) / 2.0)), size: image.size)
+                    }
+                    strongSelf.checkIconNode.isHidden = !item.checked
+                    
+                    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.insertSubnode(strongSelf.maskNode, at: 3)
+                    }
+                    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
+                    switch neighbors.bottom {
+                        case .sameSection(false):
+                            bottomStripeInset = leftInset
+                            strongSelf.bottomStripeNode.isHidden = false
+                        default:
+                            bottomStripeInset = 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.maskNode.frame = strongSelf.backgroundNode.frame.insetBy(dx: params.leftInset, dy: 0.0)
+                    strongSelf.topStripeNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: params.width, height: separatorHeight))
+                    strongSelf.bottomStripeNode.frame = CGRect(origin: CGPoint(x: bottomStripeInset, y: contentSize.height - separatorHeight), size: CGSize(width: params.width - bottomStripeInset - params.rightInset - separatorRightInset, height: separatorHeight))
+                    
+                    strongSelf.titleNode.frame = CGRect(origin: CGPoint(x: leftInset, y: floorToScreenPixels((contentSize.height - titleLayout.size.height) / 2.0) + 1.0), size: titleLayout.size)
+                    
+                    strongSelf.highlightedBackgroundNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -UIScreenPixel), size: CGSize(width: params.width, height: contentSize.height + UIScreenPixel + UIScreenPixel))
+                }
+            })
+        }
+    }
+    
+    override public func setHighlighted(_ highlighted: Bool, at point: CGPoint, animated: Bool) {
+        super.setHighlighted(highlighted, at: point, animated: animated)
+        
+        if highlighted {
+            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 public func animateInsertion(_ currentTimestamp: Double, duration: Double, options: ListViewItemAnimationOptions) {
+        self.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.4)
+    }
+    
+    override public func animateRemoved(_ currentTimestamp: Double, duration: Double) {
+        self.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.15, removeOnCompletion: false)
+    }
+}

submodules/SettingsUI/Sources/Data and Storage/WebBrowserSettingsController.swift

@@ -0,0 +1,512 @@
+import Foundation
+import UIKit
+import Display
+import SwiftSignalKit
+import Postbox
+import TelegramCore
+import TelegramPresentationData
+import TelegramUIPreferences
+import PresentationDataUtils
+import ItemListUI
+import AccountContext
+import OpenInExternalAppUI
+import ItemListPeerActionItem
+import UndoUI
+import WebKit
+import LinkPresentation
+import CoreServices
+import PersistentStringHash
+import UrlHandling
+
+private final class WebBrowserSettingsControllerArguments {
+    let context: AccountContext
+    let updateDefaultBrowser: (String?) -> Void
+    let clearCookies: () -> Void
+    let clearCache: () -> Void
+    let addException: () -> Void
+    let removeException: (String) -> Void
+    let clearExceptions: () -> Void
+    
+    init(
+        context: AccountContext,
+        updateDefaultBrowser: @escaping (String?) -> Void,
+        clearCookies: @escaping () -> Void,
+        clearCache: @escaping () -> Void,
+        addException: @escaping () -> Void,
+        removeException: @escaping (String) -> Void,
+        clearExceptions: @escaping () -> Void
+    ) {
+        self.context = context
+        self.updateDefaultBrowser = updateDefaultBrowser
+        self.clearCookies = clearCookies
+        self.clearCache = clearCache
+        self.addException = addException
+        self.removeException = removeException
+        self.clearExceptions = clearExceptions
+    }
+}
+
+private enum WebBrowserSettingsSection: Int32 {
+    case browsers
+    case clearCookies
+    case exceptions
+}
+
+private enum WebBrowserSettingsControllerEntry: ItemListNodeEntry {
+    case browserHeader(PresentationTheme, String)
+    case browser(PresentationTheme, String, OpenInApplication?, String?, Bool, Int32)
+    
+    case clearCookies(PresentationTheme, String)
+    case clearCache(PresentationTheme, String)
+    case clearCookiesInfo(PresentationTheme, String)
+    
+    case exceptionsHeader(PresentationTheme, String)
+    case exceptionsAdd(PresentationTheme, String)
+    case exception(Int32, PresentationTheme, WebBrowserException)
+    case exceptionsClear(PresentationTheme, String)
+    case exceptionsInfo(PresentationTheme, String)
+    
+    var section: ItemListSectionId {
+        switch self {
+            case .browserHeader, .browser:
+                return WebBrowserSettingsSection.browsers.rawValue
+            case .clearCookies, .clearCache, .clearCookiesInfo:
+                return WebBrowserSettingsSection.clearCookies.rawValue
+            case .exceptionsHeader, .exceptionsAdd, .exception, .exceptionsClear, .exceptionsInfo:
+                return WebBrowserSettingsSection.exceptions.rawValue
+        }
+    }
+    
+    var stableId: UInt64 {
+        switch self {
+            case .browserHeader:
+                return 0
+            case let .browser(_, _, _, _, _, index):
+                return UInt64(1 + index)
+            case .clearCookies:
+                return 102
+            case .clearCache:
+                return 103
+            case .clearCookiesInfo:
+                return 104
+            case .exceptionsHeader:
+                return 105
+            case .exceptionsAdd:
+                return 106
+            case let .exception(_, _, exception):
+                return 2000 + exception.domain.persistentHashValue
+            case .exceptionsClear:
+                return 1000
+            case .exceptionsInfo:
+                return 1001
+        }
+    }
+    
+    var sortId: Int32 {
+        switch self {
+            case .browserHeader:
+                return 0
+            case let .browser(_, _, _, _, _, index):
+                return 1 + index
+            case .clearCookies:
+                return 102
+            case .clearCache:
+                return 103
+            case .clearCookiesInfo:
+                return 104
+            case .exceptionsHeader:
+                return 105
+            case .exceptionsAdd:
+                return 106
+            case let .exception(index, _, _):
+                return 107 + index
+            case .exceptionsClear:
+                return 1000
+            case .exceptionsInfo:
+                return 1001
+        }
+    }
+    
+    static func ==(lhs: WebBrowserSettingsControllerEntry, rhs: WebBrowserSettingsControllerEntry) -> Bool {
+        switch lhs {
+            case let .browserHeader(lhsTheme, lhsText):
+                if case let .browserHeader(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .browser(lhsTheme, lhsTitle, lhsApplication, lhsIdentifier, lhsSelected, lhsIndex):
+                if case let .browser(rhsTheme, rhsTitle, rhsApplication, rhsIdentifier, rhsSelected, rhsIndex) = rhs, lhsTheme === rhsTheme, lhsTitle == rhsTitle, lhsApplication == rhsApplication, lhsIdentifier == rhsIdentifier, lhsSelected == rhsSelected, lhsIndex == rhsIndex {
+                    return true
+                } else {
+                    return false
+                }
+            case let .clearCookies(lhsTheme, lhsText):
+                if case let .clearCookies(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .clearCache(lhsTheme, lhsText):
+                if case let .clearCache(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .clearCookiesInfo(lhsTheme, lhsText):
+                if case let .clearCookiesInfo(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .exceptionsHeader(lhsTheme, lhsText):
+                if case let .exceptionsHeader(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .exception(lhsIndex, lhsTheme, lhsException):
+                if case let .exception(rhsIndex, rhsTheme, rhsException) = rhs, lhsIndex == rhsIndex, lhsTheme === rhsTheme, lhsException == rhsException {
+                    return true
+                } else {
+                    return false
+                }
+            case let .exceptionsAdd(lhsTheme, lhsText):
+                if case let .exceptionsAdd(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .exceptionsClear(lhsTheme, lhsText):
+                if case let .exceptionsClear(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .exceptionsInfo(lhsTheme, lhsText):
+                if case let .exceptionsInfo(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+        }
+    }
+        
+    static func <(lhs: WebBrowserSettingsControllerEntry, rhs: WebBrowserSettingsControllerEntry) -> Bool {
+        return lhs.sortId < rhs.sortId
+    }
+    
+    func item(presentationData: ItemListPresentationData, arguments: Any) -> ListViewItem {
+        let arguments = arguments as! WebBrowserSettingsControllerArguments
+        switch self {
+            case let .browserHeader(_, text):
+                return ItemListSectionHeaderItem(presentationData: presentationData, text: text, sectionId: self.section)
+            case let .browser(_, title, application, identifier, selected, _):
+                return WebBrowserItem(context: arguments.context, presentationData: presentationData, systemStyle: .glass, title: title, application: application, checked: selected, sectionId: self.section) {
+                    arguments.updateDefaultBrowser(identifier)
+                }
+            case let .clearCookies(_, text):
+                return ItemListPeerActionItem(presentationData: presentationData, systemStyle: .glass, icon: PresentationResourcesItemList.accentDeleteIconImage(presentationData.theme), title: text, sectionId: self.section, height: .generic, color: .accent, editing: false, action: {
+                    arguments.clearCookies()
+                })
+            case let .clearCache(_, text):
+                return ItemListPeerActionItem(presentationData: presentationData, systemStyle: .glass, icon: PresentationResourcesItemList.accentDeleteIconImage(presentationData.theme), title: text, sectionId: self.section, height: .generic, color: .accent, editing: false, action: {
+                    arguments.clearCache()
+                })
+            case let .clearCookiesInfo(_, text):
+                return ItemListTextItem(presentationData: presentationData, text: .plain(text), sectionId: self.section)
+            case let .exceptionsHeader(_, text):
+                return ItemListSectionHeaderItem(presentationData: presentationData, text: text, sectionId: self.section)
+            case let .exception(_, _, exception):
+                return WebBrowserDomainExceptionItem(presentationData: presentationData, systemStyle: .glass, context: arguments.context, title: exception.title, label: exception.domain, icon: exception.icon, sectionId: self.section, style: .blocks, deleted: {
+                    arguments.removeException(exception.domain)
+                })
+            case let .exceptionsAdd(_, text):
+                return ItemListPeerActionItem(presentationData: presentationData, systemStyle: .glass, icon: PresentationResourcesItemList.plusIconImage(presentationData.theme), title: text, sectionId: self.section, height: .generic, color: .accent, editing: false, action: {
+                    arguments.addException()
+                })
+            case let .exceptionsClear(_, text):
+                return ItemListPeerActionItem(presentationData: presentationData, systemStyle: .glass, icon: PresentationResourcesItemList.deleteIconImage(presentationData.theme), title: text, sectionId: self.section, height: .generic, color: .destructive, editing: false, action: {
+                    arguments.clearExceptions()
+                })
+            case let .exceptionsInfo(_, text):
+                return ItemListTextItem(presentationData: presentationData, text: .plain(text), sectionId: self.section)
+        }
+    }
+}
+
+private func webBrowserSettingsControllerEntries(context: AccountContext, presentationData: PresentationData, settings: WebBrowserSettings) -> [WebBrowserSettingsControllerEntry] {
+    var entries: [WebBrowserSettingsControllerEntry] = []
+    
+    let options = availableOpenInOptions(context: context, item: .url(url: "http://telegram.org"))
+    
+    entries.append(.browserHeader(presentationData.theme, presentationData.strings.WebBrowser_OpenLinksIn_Title))
+    entries.append(.browser(presentationData.theme, presentationData.strings.WebBrowser_Telegram, nil, nil, settings.defaultWebBrowser == nil, 0))
+    
+    var index: Int32 = 1
+    for option in options {
+        entries.append(.browser(presentationData.theme, option.title, option.application, option.identifier, option.identifier == settings.defaultWebBrowser, index))
+        index += 1
+    }
+    
+    if settings.defaultWebBrowser == nil {
+        entries.append(.clearCookies(presentationData.theme, presentationData.strings.WebBrowser_ClearCookies))
+//        entries.append(.clearCache(presentationData.theme, presentationData.strings.WebBrowser_ClearCache))
+        entries.append(.clearCookiesInfo(presentationData.theme, presentationData.strings.WebBrowser_ClearCookies_Info))
+        
+        entries.append(.exceptionsHeader(presentationData.theme, presentationData.strings.WebBrowser_Exceptions_Title))
+        entries.append(.exceptionsAdd(presentationData.theme, presentationData.strings.WebBrowser_Exceptions_AddException))
+        
+        var exceptionIndex: Int32 = 0
+        for exception in settings.exceptions.reversed() {
+            entries.append(.exception(exceptionIndex, presentationData.theme, exception))
+            exceptionIndex += 1
+        }
+        
+        if !settings.exceptions.isEmpty {
+            entries.append(.exceptionsClear(presentationData.theme, presentationData.strings.WebBrowser_Exceptions_Clear))
+        }
+        
+        entries.append(.exceptionsInfo(presentationData.theme, presentationData.strings.WebBrowser_Exceptions_Info))
+    }
+    
+    return entries
+}
+
+public func webBrowserSettingsController(context: AccountContext) -> ViewController {
+    var clearCookiesImpl: (() -> Void)?
+    var clearCacheImpl: (() -> Void)?
+    var addExceptionImpl: (() -> Void)?
+    var removeExceptionImpl: ((String) -> Void)?
+    var clearExceptionsImpl: (() -> Void)?
+    
+    let arguments = WebBrowserSettingsControllerArguments(
+        context: context,
+        updateDefaultBrowser: { identifier in
+            let _ = updateWebBrowserSettingsInteractively(accountManager: context.sharedContext.accountManager, {
+                $0.withUpdatedDefaultWebBrowser(identifier)
+            }).start()
+        },
+        clearCookies: {
+            clearCookiesImpl?()
+        },
+        clearCache: {
+            clearCacheImpl?()
+        },
+        addException: {
+            addExceptionImpl?()
+        },
+        removeException: { domain in
+            removeExceptionImpl?(domain)
+        },
+        clearExceptions: {
+            clearExceptionsImpl?()
+        }
+    )
+    
+    let previousSettings = Atomic<WebBrowserSettings?>(value: nil)
+    
+    let signal = combineLatest(
+        context.sharedContext.presentationData,
+        context.sharedContext.accountManager.sharedData(keys: [ApplicationSpecificSharedDataKeys.webBrowserSettings])
+    )
+    |> deliverOnMainQueue
+    |> map { presentationData, sharedData -> (ItemListControllerState, (ItemListNodeState, Any)) in
+        let settings = sharedData.entries[ApplicationSpecificSharedDataKeys.webBrowserSettings]?.get(WebBrowserSettings.self) ?? WebBrowserSettings.defaultSettings
+        let previousSettings = previousSettings.swap(settings)
+        
+        var animateChanges = false
+        if let previousSettings {
+            if previousSettings.defaultWebBrowser != settings.defaultWebBrowser {
+                animateChanges = true
+            }
+            if previousSettings.exceptions.count != settings.exceptions.count {
+                animateChanges = true
+            }
+        }
+        
+        let controllerState = ItemListControllerState(presentationData: ItemListPresentationData(presentationData), title: .text(presentationData.strings.WebBrowser_Title), leftNavigationButton: nil, rightNavigationButton: nil, backNavigationButton: ItemListBackButton(title: presentationData.strings.Common_Back))
+        let listState = ItemListNodeState(presentationData: ItemListPresentationData(presentationData), entries: webBrowserSettingsControllerEntries(context: context, presentationData: presentationData, settings: settings), style: .blocks, animateChanges: animateChanges)
+        
+        return (controllerState, (listState, arguments))
+    }
+    
+    let controller = ItemListController(context: context, state: signal)
+    
+    clearCookiesImpl = { [weak controller] in
+        let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+        
+        let alertController = textAlertController(
+            context: context,
+            updatedPresentationData: nil,
+            title: nil,
+            text: presentationData.strings.WebBrowser_ClearCookies_ClearConfirmation_Text,
+            actions: [
+                TextAlertAction(type: .genericAction, title: presentationData.strings.Common_Cancel, action: {}),
+                TextAlertAction(type: .defaultAction, title: presentationData.strings.WebBrowser_ClearCookies_ClearConfirmation_Clear, action: {
+                    WKWebsiteDataStore.default().removeData(ofTypes: [WKWebsiteDataTypeCookies, WKWebsiteDataTypeLocalStorage, WKWebsiteDataTypeSessionStorage], modifiedSince: Date(timeIntervalSince1970: 0), completionHandler:{})
+                            
+                    let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+                    controller?.present(UndoOverlayController(
+                        presentationData: presentationData,
+                        content: .info(
+                            title: nil,
+                            text: presentationData.strings.WebBrowser_ClearCookies_Succeed,
+                            timeout: nil,
+                            customUndoText: nil
+                        ),
+                        elevatedLayout: false,
+                        position: .bottom,
+                        action: { _ in return false }), in: .current
+                    )
+                })
+            ]
+        )
+        controller?.present(alertController, in: .window(.root))
+    }
+    
+    clearCacheImpl = { [weak controller] in
+        let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+        
+        let alertController = textAlertController(
+            context: context,
+            updatedPresentationData: nil,
+            title: nil,
+            text: presentationData.strings.WebBrowser_ClearCache_ClearConfirmation_Text,
+            actions: [
+                TextAlertAction(type: .genericAction, title: presentationData.strings.Common_Cancel, action: {}),
+                TextAlertAction(type: .defaultAction, title: presentationData.strings.WebBrowser_ClearCache_ClearConfirmation_Clear, action: {
+                    WKWebsiteDataStore.default().removeData(ofTypes: [WKWebsiteDataTypeDiskCache, WKWebsiteDataTypeMemoryCache], modifiedSince: Date(timeIntervalSince1970: 0), completionHandler:{})
+                            
+                    let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+                    controller?.present(UndoOverlayController(
+                        presentationData: presentationData,
+                        content: .info(
+                            title: nil,
+                            text: presentationData.strings.WebBrowser_ClearCache_Succeed,
+                            timeout: nil,
+                            customUndoText: nil
+                        ),
+                        elevatedLayout: false,
+                        position: .bottom,
+                        action: { _ in return false }), in: .current
+                    )
+                })
+            ]
+        )
+        controller?.present(alertController, in: .window(.root))
+    }
+    
+    addExceptionImpl = { [weak controller] in
+        var dismissImpl: (() -> Void)?
+        let linkController = webBrowserDomainController(context: context, apply: { url in
+            if let url {
+                let _ = (fetchDomainExceptionInfo(context: context, url: url)
+                |> deliverOnMainQueue).startStandalone(next: { newException in
+                    let _ = updateWebBrowserSettingsInteractively(accountManager: context.sharedContext.accountManager, { currentSettings in
+                        var currentExceptions = currentSettings.exceptions
+                        for exception in currentExceptions {
+                            if exception.domain == newException.domain {
+                                return currentSettings
+                            }
+                        }
+                        currentExceptions.append(newException)
+                        return currentSettings.withUpdatedExceptions(currentExceptions)
+                    }).start()
+                    dismissImpl?()
+                })
+            }
+        })
+        dismissImpl = { [weak linkController] in
+            linkController?.view.endEditing(true)
+            linkController?.dismissAnimated()
+        }
+        controller?.present(linkController, in: .window(.root))
+    }
+    
+    removeExceptionImpl = { domain in
+        let _ = updateWebBrowserSettingsInteractively(accountManager: context.sharedContext.accountManager, { currentSettings in
+            let updatedExceptions = currentSettings.exceptions.filter { $0.domain != domain  }
+            return currentSettings.withUpdatedExceptions(updatedExceptions)
+        }).start()
+    }
+    
+    clearExceptionsImpl = { [weak controller] in
+        let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+        
+        let alertController = textAlertController(
+            context: context,
+            updatedPresentationData: nil,
+            title: nil,
+            text: presentationData.strings.WebBrowser_Exceptions_ClearConfirmation_Text,
+            actions: [
+                TextAlertAction(type: .genericAction, title: presentationData.strings.Common_Cancel, action: {}),
+                TextAlertAction(type: .defaultAction, title: presentationData.strings.WebBrowser_Exceptions_ClearConfirmation_Clear, action: {
+                    let _ = updateWebBrowserSettingsInteractively(accountManager: context.sharedContext.accountManager, { currentSettings in
+                        return currentSettings.withUpdatedExceptions([])
+                    }).start()
+                })
+            ]
+        )
+        controller?.present(alertController, in: .window(.root))
+    }
+    
+    return controller
+}
+
+private func fetchDomainExceptionInfo(context: AccountContext, url: String) -> Signal<WebBrowserException, NoError> {
+    let (domain, domainUrl) = cleanDomain(url: url)
+    if #available(iOS 13.0, *), let url = URL(string: domainUrl) {
+        return Signal { subscriber in
+            let metadataProvider = LPMetadataProvider()
+            metadataProvider.shouldFetchSubresources = true
+            metadataProvider.startFetchingMetadata(for: url, completionHandler: { metadata, _ in
+                let completeWithImage: (Data?) -> Void = { imageData in
+                    var image: TelegramMediaImage?
+                    if let imageData, let parsedImage = UIImage(data: imageData) {
+                        let resource = LocalFileMediaResource(fileId: Int64.random(in: Int64.min ... Int64.max))
+                        context.sharedContext.accountManager.mediaBox.storeResourceData(resource.id, data: imageData)
+                        image = TelegramMediaImage(
+                            imageId: MediaId(namespace: Namespaces.Media.LocalImage, id: Int64.random(in: Int64.min ... Int64.max)),
+                            representations: [
+                                TelegramMediaImageRepresentation(
+                                    dimensions: PixelDimensions(width: Int32(parsedImage.size.width), height: Int32(parsedImage.size.height)),
+                                    resource: resource,
+                                    progressiveSizes: [],
+                                    immediateThumbnailData: nil,
+                                    hasVideo: false,
+                                    isPersonal: false
+                                )
+                            ],
+                            immediateThumbnailData: nil,
+                            reference: nil,
+                            partialReference: nil,
+                            flags: []
+                        )
+                    }
+                    
+                    let title = metadata?.value(forKey: "_siteName") as? String ?? metadata?.title
+                    subscriber.putNext(WebBrowserException(domain: domain, title: title ?? domain, icon: image))
+                    subscriber.putCompletion()
+                }
+                
+                if let imageProvider = metadata?.iconProvider {
+                    imageProvider.loadFileRepresentation(forTypeIdentifier: kUTTypeImage as String, completionHandler: { imageUrl, _ in
+                        guard let imageUrl, let imageData = try? Data(contentsOf: imageUrl) else {
+                            completeWithImage(nil)
+                            return
+                        }
+                        completeWithImage(imageData)
+                    })
+                } else {
+                    completeWithImage(nil)
+                }
+            })
+            return ActionDisposable {
+                metadataProvider.cancel()
+            }
+        }
+    } else {
+        return .single(WebBrowserException(domain: domain, title: domain, icon: nil))
+    }
+}