Merge commit '7621e2f8dec938cf48181c8b10afc9b01f444e68' into beta

submodules/SettingsUI/Sources/Notifications/Exceptions/NotificationExceptionSettingsController.swift

@@ -0,0 +1 @@
+

submodules/SettingsUI/Sources/Notifications/Exceptions/NotificationExceptions.swift

@@ -0,0 +1,191 @@
+import Foundation
+import UIKit
+import Display
+import SwiftSignalKit
+import Postbox
+import TelegramCore
+import TelegramPresentationData
+import AccountContext
+import SearchUI
+import NotificationPeerExceptionController
+
+public class NotificationExceptionsController: ViewController {
+    private let context: AccountContext
+    
+    private var controllerNode: NotificationExceptionsControllerNode {
+        return self.displayNode as! NotificationExceptionsControllerNode
+    }
+    
+    private var _ready = Promise<Bool>()
+    override public var ready: Promise<Bool> {
+        return self._ready
+    }
+    
+    private var presentationData: PresentationData
+    private var presentationDataDisposable: Disposable?
+    
+    private var removeAllItem: UIBarButtonItem!
+    private var editItem: UIBarButtonItem!
+    private var doneItem: UIBarButtonItem!
+    
+    private let mode: NotificationExceptionMode
+    private let updatedMode: (NotificationExceptionMode) -> Void
+    
+    private var searchContentNode: NavigationBarSearchContentNode?
+    
+    public init(context: AccountContext, mode: NotificationExceptionMode, updatedMode: @escaping(NotificationExceptionMode) -> Void) {
+        self.context = context
+        self.mode = mode
+        self.updatedMode = updatedMode
+        self.presentationData = context.sharedContext.currentPresentationData.with { $0 }
+        
+        super.init(navigationBarPresentationData: NavigationBarPresentationData(presentationData: self.presentationData))
+        
+        self.removeAllItem = UIBarButtonItem(title: self.presentationData.strings.Notification_Exceptions_DeleteAll, style: .plain, target: self, action: #selector(self.removeAllPressed))
+        self.editItem = UIBarButtonItem(title: self.presentationData.strings.Common_Done, style: .done, target: self, action: #selector(self.editPressed))
+        self.doneItem = UIBarButtonItem(title: self.presentationData.strings.Common_Edit, style: .plain, target: self, action: #selector(self.editPressed))
+        
+        self.statusBar.statusBarStyle = self.presentationData.theme.rootController.statusBarStyle.style
+        
+        self.title = self.presentationData.strings.Notifications_ExceptionsTitle
+        
+        self.navigationItem.backBarButtonItem = UIBarButtonItem(title: self.presentationData.strings.Common_Back, style: .plain, target: nil, action: nil)
+        
+        self.scrollToTop = { [weak self] in
+            if let strongSelf = self {
+                if let searchContentNode = strongSelf.searchContentNode {
+                    searchContentNode.updateExpansionProgress(1.0, animated: true)
+                }
+                strongSelf.controllerNode.scrollToTop()
+            }
+        }
+        
+        self.presentationDataDisposable = (context.sharedContext.presentationData
+        |> deliverOnMainQueue).start(next: { [weak self] presentationData in
+            if let strongSelf = self {
+                let previousTheme = strongSelf.presentationData.theme
+                let previousStrings = strongSelf.presentationData.strings
+                
+                strongSelf.presentationData = presentationData
+                
+                if previousTheme !== presentationData.theme || previousStrings !== presentationData.strings {
+                    strongSelf.updateThemeAndStrings()
+                }
+            }
+        })
+        
+        self.searchContentNode = NavigationBarSearchContentNode(theme: self.presentationData.theme, placeholder: self.presentationData.strings.Common_Search, activate: { [weak self] in
+            self?.activateSearch()
+        })
+        self.navigationBar?.setContentNode(self.searchContentNode, animated: false)
+    }
+    
+    required public init(coder aDecoder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+    
+    deinit {
+        self.presentationDataDisposable?.dispose()
+    }
+    
+    private func updateThemeAndStrings() {
+        self.statusBar.statusBarStyle = self.presentationData.theme.rootController.statusBarStyle.style
+        self.navigationBar?.updatePresentationData(NavigationBarPresentationData(presentationData: self.presentationData))
+        self.searchContentNode?.updateThemeAndPlaceholder(theme: self.presentationData.theme, placeholder: self.presentationData.strings.Common_Search)
+        self.title = self.presentationData.strings.Notifications_ExceptionsTitle
+        self.navigationItem.backBarButtonItem = UIBarButtonItem(title: self.presentationData.strings.Common_Back, style: .plain, target: nil, action: nil)
+        self.controllerNode.updatePresentationData(self.presentationData)
+        
+        let removeAllItem = UIBarButtonItem(title: self.presentationData.strings.Notification_Exceptions_DeleteAll, style: .plain, target: self, action: #selector(self.removeAllPressed))
+        let editItem = UIBarButtonItem(title: self.presentationData.strings.Common_Done, style: .done, target: self, action: #selector(self.editPressed))
+        let doneItem = UIBarButtonItem(title: self.presentationData.strings.Common_Edit, style: .plain, target: self, action: #selector(self.editPressed))
+        if self.navigationItem.rightBarButtonItem === self.editItem {
+            self.navigationItem.rightBarButtonItem = editItem
+        } else if self.navigationItem.rightBarButtonItem === self.doneItem {
+            self.navigationItem.rightBarButtonItem = doneItem
+            self.navigationItem.leftBarButtonItem = removeAllItem
+        }
+        self.removeAllItem = removeAllItem
+        self.editItem = editItem
+        self.doneItem = doneItem
+    }
+    
+    override public func loadDisplayNode() {
+        self.displayNode = NotificationExceptionsControllerNode(context: self.context, presentationData: self.presentationData, navigationBar: self.navigationBar!, mode: self.mode, updatedMode: self.updatedMode, requestActivateSearch: { [weak self] in
+            self?.activateSearch()
+            }, requestDeactivateSearch: { [weak self] animated in
+                self?.deactivateSearch(animated: animated)
+            }, updateCanStartEditing: { [weak self] value in
+                guard let strongSelf = self else {
+                    return
+                }
+                var leftItem: UIBarButtonItem?
+                var item: UIBarButtonItem?
+                if let value = value {
+                    item = value ? strongSelf.editItem : strongSelf.doneItem
+                    leftItem = value ? strongSelf.removeAllItem : nil
+                }
+                if strongSelf.navigationItem.leftBarButtonItem !== leftItem {
+                    strongSelf.navigationItem.setLeftBarButton(leftItem, animated: true)
+                }
+                if strongSelf.navigationItem.rightBarButtonItem !== item {
+                    strongSelf.navigationItem.setRightBarButton(item, animated: true)
+                }
+            }, present: { [weak self] c, a in
+                self?.present(c, in: .window(.root), with: a)
+            }, pushController: { [weak self] c in
+                (self?.navigationController as? NavigationController)?.pushViewController(c)
+            })
+        
+        self.controllerNode.listNode.visibleContentOffsetChanged = { [weak self] offset in
+            if let strongSelf = self, let searchContentNode = strongSelf.searchContentNode {
+                searchContentNode.updateListVisibleContentOffset(offset)
+            }
+        }
+        
+        self.controllerNode.listNode.didEndScrolling = { [weak self] _ in
+            if let strongSelf = self, let searchContentNode = strongSelf.searchContentNode {
+                let _ = fixNavigationSearchableListNodeScrolling(strongSelf.controllerNode.listNode, searchNode: searchContentNode)
+            }
+        }
+        
+        self._ready.set(self.controllerNode._ready.get())
+        
+        self.displayNodeDidLoad()
+    }
+    
+    override public func containerLayoutUpdated(_ layout: ContainerViewLayout, transition: ContainedViewLayoutTransition) {
+        super.containerLayoutUpdated(layout, transition: transition)
+        
+        self.controllerNode.containerLayoutUpdated(layout, navigationBarHeight: self.cleanNavigationHeight, actualNavigationBarHeight: self.navigationLayout(layout: layout).navigationFrame.maxY, transition: transition)
+    }
+    
+    @objc private func removeAllPressed() {
+        self.controllerNode.removeAll()
+    }
+    
+    @objc private func editPressed() {
+        self.controllerNode.toggleEditing()
+    }
+    
+    private func activateSearch() {
+        if self.displayNavigationBar {
+            if let scrollToTop = self.scrollToTop {
+                scrollToTop()
+            }
+            if let searchContentNode = self.searchContentNode {
+                self.controllerNode.activateSearch(placeholderNode: searchContentNode.placeholderNode)
+            }
+            self.setDisplayNavigationBar(false, transition: .animated(duration: 0.5, curve: .spring))
+        }
+    }
+    
+    private func deactivateSearch(animated: Bool) {
+        if !self.displayNavigationBar {
+            self.setDisplayNavigationBar(true, transition: .animated(duration: 0.5, curve: .spring))
+            if let searchContentNode = self.searchContentNode {
+                self.controllerNode.deactivateSearch(placeholderNode: searchContentNode.placeholderNode, animated: animated)
+            }
+        }
+    }
+}

submodules/SettingsUI/Sources/Notifications/NotificationSearchItem.swift

@@ -0,0 +1,139 @@
+import Foundation
+import UIKit
+import AsyncDisplayKit
+import Postbox
+import Display
+import SwiftSignalKit
+import TelegramPresentationData
+import ItemListUI
+import PresentationDataUtils
+import SearchBarNode
+
+private let searchBarFont = Font.regular(14.0)
+
+class NotificationSearchItem: ListViewItem, ItemListItem {
+    let selectable: Bool = false
+    
+    var sectionId: ItemListSectionId {
+        return 0
+    }
+    var tag: ItemListItemTag? {
+        return nil
+    }
+    var requestsNoInset: Bool {
+        return true
+    }
+    
+    let theme: PresentationTheme
+    private let placeholder: String
+    private let activate: () -> Void
+    
+    init(theme: PresentationTheme, placeholder: String, activate: @escaping () -> Void) {
+        self.theme = theme
+        self.placeholder = placeholder
+        self.activate = activate
+    }
+    
+    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 = NotificationSearchItemNode()
+            node.placeholder = self.placeholder
+            
+            let makeLayout = node.asyncLayout()
+            let (layout, apply) = makeLayout(self, params)
+            
+            node.contentSize = layout.contentSize
+            node.insets = layout.insets
+            
+            node.activate = self.activate
+            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? NotificationSearchItemNode {
+                let layout = nodeValue.asyncLayout()
+                async {
+                    let (nodeLayout, apply) = layout(self, params)
+                    Queue.mainQueue().async {
+                        completion(nodeLayout, { _ in
+                            apply(animation.isAnimated)
+                        })
+                    }
+                }
+            }
+        }
+    }
+}
+
+class NotificationSearchItemNode: ListViewItemNode {
+    let searchBarNode: SearchBarPlaceholderNode
+    var placeholder: String?
+    
+    fileprivate var activate: (() -> Void)? {
+        didSet {
+            self.searchBarNode.activate = self.activate
+        }
+    }
+    
+    override func animateRemoved(_ currentTimestamp: Double, duration: Double) {
+        self.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.15, removeOnCompletion: false)
+    }
+    
+    required init() {
+        self.searchBarNode = SearchBarPlaceholderNode()
+        
+        super.init(layerBacked: false, dynamicBounce: false)
+        
+        self.addSubnode(self.searchBarNode)
+    }
+    
+    override func layoutForParams(_ params: ListViewItemLayoutParams, item: ListViewItem, previousItem: ListViewItem?, nextItem: ListViewItem?) {
+        let makeLayout = self.asyncLayout()
+        let (layout, apply) = makeLayout(item as! NotificationSearchItem, params)
+        apply(false)
+        self.contentSize = layout.contentSize
+        self.insets = layout.insets
+    }
+    
+    func asyncLayout() -> (_ item: NotificationSearchItem, _ params: ListViewItemLayoutParams) -> (ListViewItemNodeLayout, (Bool) -> Void) {
+        let searchBarNodeLayout = self.searchBarNode.asyncLayout()
+        let placeholder = self.placeholder
+        
+        return { item, params in
+            let baseWidth = params.width - params.leftInset - params.rightInset
+            
+            let backgroundColor = item.theme.chatList.itemBackgroundColor
+            
+            let placeholderString = NSAttributedString(string: placeholder ?? "", font: searchBarFont, textColor: UIColor(rgb: 0x8e8e93))
+            let (_, searchBarApply) = searchBarNodeLayout(placeholderString, placeholderString, CGSize(width: baseWidth - 16.0, height: 28.0), 1.0, UIColor(rgb: 0x8e8e93), item.theme.chatList.regularSearchBarColor, backgroundColor, .immediate)
+            
+            let layout = ListViewItemNodeLayout(contentSize: CGSize(width: params.width, height: 44.0), insets: UIEdgeInsets())
+            
+            return (layout, { [weak self] animated in
+                if let strongSelf = self {
+                    let transition: ContainedViewLayoutTransition
+                    if animated {
+                        transition = .animated(duration: 0.3, curve: .easeInOut)
+                    } else {
+                        transition = .immediate
+                    }
+                    
+                    strongSelf.searchBarNode.frame = CGRect(origin: CGPoint(x: params.leftInset + 8.0, y: 8.0), size: CGSize(width: baseWidth - 16.0, height: 28.0))
+                    searchBarApply()
+                    
+                    strongSelf.searchBarNode.bounds = CGRect(origin: CGPoint(), size: CGSize(width: baseWidth - 16.0, height: 28.0))
+                    
+                    transition.updateBackgroundColor(node: strongSelf, color: backgroundColor)
+                }
+            })
+        }
+    }
+}

submodules/SettingsUI/Sources/Notifications/NotificationsAndSoundsController.swift

@@ -0,0 +1,901 @@
+import Foundation
+import UIKit
+import Display
+import SwiftSignalKit
+import Postbox
+import TelegramCore
+import TelegramPresentationData
+import TelegramUIPreferences
+import DeviceAccess
+import ItemListUI
+import PresentationDataUtils
+import AccountContext
+import AlertUI
+import PresentationDataUtils
+import TelegramNotices
+import NotificationSoundSelectionUI
+import TelegramStringFormatting
+import NotificationPeerExceptionController
+
+private struct CounterTagSettings: OptionSet {
+    var rawValue: Int32
+    
+    init(rawValue: Int32) {
+        self.rawValue = rawValue
+    }
+    
+    init(summaryTags: PeerSummaryCounterTags) {
+        var result = CounterTagSettings()
+        if summaryTags.contains(.contact) {
+            result.insert(.regularChatsAndGroups)
+        }
+        if summaryTags.contains(.channel) {
+            result.insert(.channels)
+        }
+        self = result
+    }
+    
+    func toSumaryTags() -> PeerSummaryCounterTags {
+        var result = PeerSummaryCounterTags()
+        if self.contains(.regularChatsAndGroups) {
+            result.insert(.contact)
+            result.insert(.nonContact)
+            result.insert(.bot)
+            result.insert(.group)
+        }
+        if self.contains(.channels) {
+            result.insert(.channel)
+        }
+        return result
+    }
+    
+    static let regularChatsAndGroups = CounterTagSettings(rawValue: 1 << 0)
+    static let channels = CounterTagSettings(rawValue: 1 << 1)
+}
+
+private final class NotificationsAndSoundsArguments {
+    let context: AccountContext
+    let presentController: (ViewController, ViewControllerPresentationArguments?) -> Void
+    let pushController: (ViewController) -> Void
+    let soundSelectionDisposable: MetaDisposable
+    
+    let authorizeNotifications: () -> Void
+    let suppressWarning: () -> Void
+    
+    let openPeerCategory: (NotificationsPeerCategory) -> Void
+    let openReactions: () -> Void
+        
+    let updateInAppSounds: (Bool) -> Void
+    let updateInAppVibration: (Bool) -> Void
+    let updateInAppPreviews: (Bool) -> Void
+    
+    let updateDisplayNameOnLockscreen: (Bool) -> Void
+    let updateIncludeTag: (CounterTagSettings, Bool) -> Void
+    let updateTotalUnreadCountCategory: (Bool) -> Void
+    
+    let updateJoinedNotifications: (Bool) -> Void
+    
+    let resetNotifications: () -> Void
+        
+    let openAppSettings: () -> Void
+    
+    let updateNotificationsFromAllAccounts: (Bool) -> Void
+    
+    init(context: AccountContext, presentController: @escaping (ViewController, ViewControllerPresentationArguments?) -> Void, pushController: @escaping(ViewController)->Void, soundSelectionDisposable: MetaDisposable, authorizeNotifications: @escaping () -> Void, suppressWarning: @escaping () -> Void, openPeerCategory: @escaping (NotificationsPeerCategory) -> Void, openReactions: @escaping () -> Void, updateInAppSounds: @escaping (Bool) -> Void, updateInAppVibration: @escaping (Bool) -> Void, updateInAppPreviews: @escaping (Bool) -> Void, updateDisplayNameOnLockscreen: @escaping (Bool) -> Void, updateIncludeTag: @escaping (CounterTagSettings, Bool) -> Void, updateTotalUnreadCountCategory: @escaping (Bool) -> Void, resetNotifications: @escaping () -> Void, openAppSettings: @escaping () -> Void, updateJoinedNotifications: @escaping (Bool) -> Void, updateNotificationsFromAllAccounts: @escaping (Bool) -> Void) {
+        self.context = context
+        self.presentController = presentController
+        self.pushController = pushController
+        self.soundSelectionDisposable = soundSelectionDisposable
+        self.authorizeNotifications = authorizeNotifications
+        self.suppressWarning = suppressWarning
+        self.openPeerCategory = openPeerCategory
+        self.openReactions = openReactions
+        self.updateInAppSounds = updateInAppSounds
+        self.updateInAppVibration = updateInAppVibration
+        self.updateInAppPreviews = updateInAppPreviews
+        self.updateDisplayNameOnLockscreen = updateDisplayNameOnLockscreen
+        self.updateIncludeTag = updateIncludeTag
+        self.updateTotalUnreadCountCategory = updateTotalUnreadCountCategory
+        self.resetNotifications = resetNotifications
+        self.openAppSettings = openAppSettings
+        self.updateJoinedNotifications = updateJoinedNotifications
+        self.updateNotificationsFromAllAccounts = updateNotificationsFromAllAccounts
+    }
+}
+
+private enum NotificationsAndSoundsSection: Int32 {
+    case accounts
+    case permission
+    case categories
+    case inApp
+    case displayNamesOnLockscreen
+    case badge
+    case joinedNotifications
+    case reset
+}
+
+public enum NotificationsAndSoundsEntryTag: ItemListItemTag {
+    case allAccounts
+    case inAppSounds
+    case inAppVibrate
+    case inAppPreviews
+    case displayNamesOnLockscreen
+    case includeChannels
+    case unreadCountCategory
+    case joinedNotifications
+    case reset
+    
+    public func isEqual(to other: ItemListItemTag) -> Bool {
+        if let other = other as? NotificationsAndSoundsEntryTag, self == other {
+            return true
+        } else {
+            return false
+        }
+    }
+}
+
+private enum NotificationsAndSoundsEntry: ItemListNodeEntry {
+    case accountsHeader(PresentationTheme, String)
+    case allAccounts(PresentationTheme, String, Bool)
+    case accountsInfo(PresentationTheme, String)
+    
+    case permissionInfo(PresentationTheme, String, String, Bool)
+    case permissionEnable(PresentationTheme, String)
+    
+    case categoriesHeader(PresentationTheme, String)
+    case privateChats(PresentationTheme, String, String, String)
+    case groupChats(PresentationTheme, String, String, String)
+    case channels(PresentationTheme, String, String, String)
+    case stories(PresentationTheme, String, String, String)
+    case reactions(PresentationTheme, String, String, String)
+    
+    case inAppHeader(PresentationTheme, String)
+    case inAppSounds(PresentationTheme, String, Bool)
+    case inAppVibrate(PresentationTheme, String, Bool)
+    case inAppPreviews(PresentationTheme, String, Bool)
+    
+    case displayNamesOnLockscreen(PresentationTheme, String, Bool)
+    case displayNamesOnLockscreenInfo(PresentationTheme, String)
+    
+    case badgeHeader(PresentationTheme, String)
+    case includeChannels(PresentationTheme, String, Bool)
+    case unreadCountCategory(PresentationTheme, String, Bool)
+    case unreadCountCategoryInfo(PresentationTheme, String)
+    
+    case joinedNotifications(PresentationTheme, String, Bool)
+    case joinedNotificationsInfo(PresentationTheme, String)
+    
+    case reset(PresentationTheme, String)
+    case resetNotice(PresentationTheme, String)
+    
+    var section: ItemListSectionId {
+        switch self {
+            case .accountsHeader, .allAccounts, .accountsInfo:
+                return NotificationsAndSoundsSection.accounts.rawValue
+            case .permissionInfo, .permissionEnable:
+                return NotificationsAndSoundsSection.permission.rawValue
+            case .categoriesHeader, .privateChats, .groupChats, .channels, .stories, .reactions:
+                return NotificationsAndSoundsSection.categories.rawValue
+            case .inAppHeader, .inAppSounds, .inAppVibrate, .inAppPreviews:
+                return NotificationsAndSoundsSection.inApp.rawValue
+            case .displayNamesOnLockscreen, .displayNamesOnLockscreenInfo:
+                return NotificationsAndSoundsSection.displayNamesOnLockscreen.rawValue
+            case .badgeHeader, .includeChannels, .unreadCountCategory, .unreadCountCategoryInfo:
+                return NotificationsAndSoundsSection.badge.rawValue
+            case .joinedNotifications, .joinedNotificationsInfo:
+                return NotificationsAndSoundsSection.joinedNotifications.rawValue
+            case .reset, .resetNotice:
+                return NotificationsAndSoundsSection.reset.rawValue
+        }
+    }
+    
+    var stableId: Int32 {
+        switch self {
+            case .accountsHeader:
+                return 0
+            case .allAccounts:
+                return 1
+            case .accountsInfo:
+                return 2
+            case .permissionInfo:
+                return 3
+            case .permissionEnable:
+                return 4
+            case .categoriesHeader:
+                return 5
+            case .privateChats:
+                return 6
+            case .groupChats:
+                return 7
+            case .channels:
+                return 8
+            case .stories:
+                return 9
+            case .reactions:
+                return 10
+            case .inAppHeader:
+                return 14
+            case .inAppSounds:
+                return 15
+            case .inAppVibrate:
+                return 16
+            case .inAppPreviews:
+                return 17
+            case .displayNamesOnLockscreen:
+                return 18
+            case .displayNamesOnLockscreenInfo:
+                return 19
+            case .badgeHeader:
+                return 20
+            case .includeChannels:
+                return 21
+            case .unreadCountCategory:
+                return 22
+            case .unreadCountCategoryInfo:
+                return 23
+            case .joinedNotifications:
+                return 24
+            case .joinedNotificationsInfo:
+                return 25
+            case .reset:
+                return 26
+            case .resetNotice:
+                return 27
+        }
+    }
+    
+    var tag: ItemListItemTag? {
+        switch self {
+            case .allAccounts:
+                return NotificationsAndSoundsEntryTag.allAccounts
+            case .inAppSounds:
+                return NotificationsAndSoundsEntryTag.inAppSounds
+            case .inAppVibrate:
+                return NotificationsAndSoundsEntryTag.inAppVibrate
+            case .inAppPreviews:
+                return NotificationsAndSoundsEntryTag.inAppPreviews
+            case .displayNamesOnLockscreen:
+                return NotificationsAndSoundsEntryTag.displayNamesOnLockscreen
+            case .includeChannels:
+                return NotificationsAndSoundsEntryTag.includeChannels
+            case .unreadCountCategory:
+                return NotificationsAndSoundsEntryTag.unreadCountCategory
+            case .joinedNotifications:
+                return NotificationsAndSoundsEntryTag.joinedNotifications
+            case .reset:
+                return NotificationsAndSoundsEntryTag.reset
+            default:
+                return nil
+        }
+    }
+    
+    static func ==(lhs: NotificationsAndSoundsEntry, rhs: NotificationsAndSoundsEntry) -> Bool {
+        switch lhs {
+            case let .accountsHeader(lhsTheme, lhsText):
+                if case let .accountsHeader(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .allAccounts(lhsTheme, lhsText, lhsValue):
+                if case let .allAccounts(rhsTheme, rhsText, rhsValue) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue {
+                    return true
+                } else {
+                    return false
+                }
+            case let .accountsInfo(lhsTheme, lhsText):
+                if case let .accountsInfo(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .permissionInfo(lhsTheme, lhsTitle, lhsText, lhsSuppressed):
+                if case let .permissionInfo(rhsTheme, rhsTitle, rhsText, rhsSuppressed) = rhs, lhsTheme === rhsTheme, lhsTitle == rhsTitle, lhsText == rhsText, lhsSuppressed == rhsSuppressed {
+                    return true
+                } else {
+                    return false
+            }
+            case let .permissionEnable(lhsTheme, lhsText):
+                if case let .permissionEnable(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .categoriesHeader(lhsTheme, lhsText):
+                if case let .categoriesHeader(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .privateChats(lhsTheme, lhsTitle, lhsSubtitle, lhsLabel):
+                if case let .privateChats(rhsTheme, rhsTitle, rhsSubtitle, rhsLabel) = rhs, lhsTheme === rhsTheme, lhsTitle == rhsTitle, lhsSubtitle == rhsSubtitle, lhsLabel == rhsLabel {
+                    return true
+                } else {
+                    return false
+                }
+            case let .groupChats(lhsTheme, lhsTitle, lhsSubtitle, lhsLabel):
+                if case let .groupChats(rhsTheme, rhsTitle, rhsSubtitle, rhsLabel) = rhs, lhsTheme === rhsTheme, lhsTitle == rhsTitle, lhsSubtitle == rhsSubtitle, lhsLabel == rhsLabel {
+                    return true
+                } else {
+                    return false
+                }
+            case let .channels(lhsTheme, lhsTitle, lhsSubtitle, lhsLabel):
+                if case let .channels(rhsTheme, rhsTitle, rhsSubtitle, rhsLabel) = rhs, lhsTheme === rhsTheme, lhsTitle == rhsTitle, lhsSubtitle == rhsSubtitle, lhsLabel == rhsLabel {
+                    return true
+                } else {
+                    return false
+                }
+            case let .stories(lhsTheme, lhsTitle, lhsSubtitle, lhsLabel):
+                if case let .stories(rhsTheme, rhsTitle, rhsSubtitle, rhsLabel) = rhs, lhsTheme === rhsTheme, lhsTitle == rhsTitle, lhsSubtitle == rhsSubtitle, lhsLabel == rhsLabel {
+                    return true
+                } else {
+                    return false
+                }
+            case let .reactions(lhsTheme, lhsTitle, lhsSubtitle, lhsLabel):
+                if case let .reactions(rhsTheme, rhsTitle, rhsSubtitle, rhsLabel) = rhs, lhsTheme === rhsTheme, lhsTitle == rhsTitle, lhsSubtitle == rhsSubtitle, lhsLabel == rhsLabel {
+                    return true
+                } else {
+                    return false
+                }
+            case let .inAppHeader(lhsTheme, lhsText):
+                if case let .inAppHeader(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .inAppSounds(lhsTheme, lhsText, lhsValue):
+                if case let .inAppSounds(rhsTheme, rhsText, rhsValue) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue {
+                    return true
+                } else {
+                    return false
+                }
+            case let .inAppVibrate(lhsTheme, lhsText, lhsValue):
+                if case let .inAppVibrate(rhsTheme, rhsText, rhsValue) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue {
+                    return true
+                } else {
+                    return false
+                }
+            case let .inAppPreviews(lhsTheme, lhsText, lhsValue):
+                if case let .inAppPreviews(rhsTheme, rhsText, rhsValue) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue {
+                    return true
+                } else {
+                    return false
+                }
+            case let .displayNamesOnLockscreen(lhsTheme, lhsText, lhsValue):
+                if case let .displayNamesOnLockscreen(rhsTheme, rhsText, rhsValue) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue {
+                    return true
+                } else {
+                    return false
+                }
+            case let .displayNamesOnLockscreenInfo(lhsTheme, lhsText):
+                if case let .displayNamesOnLockscreenInfo(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .badgeHeader(lhsTheme, lhsText):
+                if case let .badgeHeader(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .includeChannels(lhsTheme, lhsText, lhsValue):
+                if case let .includeChannels(rhsTheme, rhsText, rhsValue) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue {
+                    return true
+                } else {
+                    return false
+                }
+            case let .unreadCountCategory(lhsTheme, lhsText, lhsValue):
+                if case let .unreadCountCategory(rhsTheme, rhsText, rhsValue) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue {
+                    return true
+                } else {
+                    return false
+                }
+            case let .unreadCountCategoryInfo(lhsTheme, lhsText):
+                if case let .unreadCountCategoryInfo(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .joinedNotifications(lhsTheme, lhsText, lhsValue):
+                if case let .joinedNotifications(rhsTheme, rhsText, rhsValue) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue {
+                    return true
+                } else {
+                    return false
+                }
+            case let .joinedNotificationsInfo(lhsTheme, lhsText):
+                if case let .joinedNotificationsInfo(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .reset(lhsTheme, lhsText):
+                if case let .reset(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .resetNotice(lhsTheme, lhsText):
+                if case let .resetNotice(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+        }
+    }
+    
+    static func <(lhs: NotificationsAndSoundsEntry, rhs: NotificationsAndSoundsEntry) -> Bool {
+        return lhs.stableId < rhs.stableId
+    }
+    
+    func item(presentationData: ItemListPresentationData, arguments: Any) -> ListViewItem {
+        let arguments = arguments as! NotificationsAndSoundsArguments
+        switch self {
+            case let .accountsHeader(_, text):
+                return ItemListSectionHeaderItem(presentationData: presentationData, text: text, sectionId: self.section)
+            case let .allAccounts(_, text, value):
+                return ItemListSwitchItem(presentationData: presentationData, systemStyle: .glass, title: text, value: value, sectionId: self.section, style: .blocks, updated: { updatedValue in
+                    arguments.updateNotificationsFromAllAccounts(updatedValue)
+                }, tag: self.tag)
+            case let .accountsInfo(_, text):
+                return ItemListTextItem(presentationData: presentationData, text: .plain(text), sectionId: self.section)
+            case let .permissionInfo(_, title, text, suppressed):
+                return ItemListInfoItem(presentationData: presentationData, systemStyle: .glass, title: title, text: .plain(text), style: .blocks, sectionId: self.section, closeAction: suppressed ? nil : {
+                    arguments.suppressWarning()
+                })
+            case let .permissionEnable(_, text):
+                return ItemListActionItem(presentationData: presentationData, systemStyle: .glass, title: text, kind: .generic, alignment: .natural, sectionId: self.section, style: .blocks, action: {
+                    arguments.authorizeNotifications()
+                })
+            case let .categoriesHeader(_, text):
+                return ItemListSectionHeaderItem(presentationData: presentationData, text: text, sectionId: self.section)
+            case let .privateChats(_, title, subtitle, label):
+                return NotificationsCategoryItemListItem(presentationData: presentationData, systemStyle: .glass, icon: UIImage(bundleImageName: "Settings/Menu/EditProfile"), title: title, subtitle: subtitle, label: label, sectionId: self.section, style: .blocks, action: {
+                    arguments.openPeerCategory(.privateChat)
+                })
+            case let .groupChats(_, title, subtitle, label):
+                return NotificationsCategoryItemListItem(presentationData: presentationData, systemStyle: .glass, icon: UIImage(bundleImageName: "Settings/Menu/GroupChats"), title: title, subtitle: subtitle, label: label, sectionId: self.section, style: .blocks, action: {
+                    arguments.openPeerCategory(.group)
+                })
+            case let .channels(_, title, subtitle, label):
+                return NotificationsCategoryItemListItem(presentationData: presentationData, systemStyle: .glass, icon: UIImage(bundleImageName: "Settings/Menu/Channels"), title: title, subtitle: subtitle, label: label, sectionId: self.section, style: .blocks, action: {
+                    arguments.openPeerCategory(.channel)
+                })
+            case let .stories(_, title, subtitle, label):
+                return NotificationsCategoryItemListItem(presentationData: presentationData, systemStyle: .glass, icon: PresentationResourcesSettings.stories, title: title, subtitle: subtitle, label: label, sectionId: self.section, style: .blocks, action: {
+                    arguments.openPeerCategory(.stories)
+                })
+            case let .reactions(_, title, subtitle, label):
+                return NotificationsCategoryItemListItem(presentationData: presentationData, systemStyle: .glass, icon: PresentationResourcesSettings.reactions, title: title, subtitle: subtitle, label: label, sectionId: self.section, style: .blocks, action: {
+                    arguments.openReactions()
+                })
+            case let .inAppHeader(_, text):
+                return ItemListSectionHeaderItem(presentationData: presentationData, text: text, sectionId: self.section)
+            case let .inAppSounds(_, text, value):
+                return ItemListSwitchItem(presentationData: presentationData, systemStyle: .glass, title: text, value: value, sectionId: self.section, style: .blocks, updated: { updatedValue in
+                    arguments.updateInAppSounds(updatedValue)
+                }, tag: self.tag)
+            case let .inAppVibrate(_, text, value):
+                return ItemListSwitchItem(presentationData: presentationData, systemStyle: .glass, title: text, value: value, sectionId: self.section, style: .blocks, updated: { updatedValue in
+                    arguments.updateInAppVibration(updatedValue)
+                }, tag: self.tag)
+            case let .inAppPreviews(_, text, value):
+                return ItemListSwitchItem(presentationData: presentationData, systemStyle: .glass, title: text, value: value, sectionId: self.section, style: .blocks, updated: { updatedValue in
+                    arguments.updateInAppPreviews(updatedValue)
+                }, tag: self.tag)
+            case let .displayNamesOnLockscreen(_, text, value):
+                return ItemListSwitchItem(presentationData: presentationData, systemStyle: .glass, title: text, value: value, sectionId: self.section, style: .blocks, updated: { updatedValue in
+                    arguments.updateDisplayNameOnLockscreen(updatedValue)
+                }, tag: self.tag)
+            case let .displayNamesOnLockscreenInfo(_, text):
+                return ItemListTextItem(presentationData: presentationData, text: .markdown(text.replacingOccurrences(of: "]", with: "]()")), sectionId: self.section, linkAction: { _ in
+                    arguments.openAppSettings()
+                })
+            case let .badgeHeader(_, text):
+                return ItemListSectionHeaderItem(presentationData: presentationData, text: text, sectionId: self.section)
+            case let .includeChannels(_, text, value):
+                return ItemListSwitchItem(presentationData: presentationData, systemStyle: .glass, title: text, value: value, sectionId: self.section, style: .blocks, updated: { updatedValue in
+                    arguments.updateIncludeTag(.channels, updatedValue)
+                }, tag: self.tag)
+            case let .unreadCountCategory(_, text, value):
+                return ItemListSwitchItem(presentationData: presentationData, systemStyle: .glass, title: text, value: value, sectionId: self.section, style: .blocks, updated: { updatedValue in
+                    arguments.updateTotalUnreadCountCategory(updatedValue)
+                }, tag: self.tag)
+            case let .unreadCountCategoryInfo(_, text):
+                return ItemListTextItem(presentationData: presentationData, text: .plain(text), sectionId: self.section)
+            case let .joinedNotifications(_, text, value):
+                return ItemListSwitchItem(presentationData: presentationData, systemStyle: .glass, title: text, value: value, sectionId: self.section, style: .blocks, updated: { updatedValue in
+                    arguments.updateJoinedNotifications(updatedValue)
+                }, tag: self.tag)
+            case let .joinedNotificationsInfo(_, text):
+                return ItemListTextItem(presentationData: presentationData, text: .plain(text), sectionId: self.section)
+            case let .reset(_, text):
+                return ItemListActionItem(presentationData: presentationData, systemStyle: .glass, title: text, kind: .destructive, alignment: .natural, sectionId: self.section, style: .blocks, action: {
+                    arguments.resetNotifications()
+                }, tag: self.tag)
+            case let .resetNotice(_, text):
+                return ItemListTextItem(presentationData: presentationData, text: .plain(text), sectionId: self.section)
+        }
+    }
+}
+
+private func filteredGlobalSound(_ sound: PeerMessageSound) -> PeerMessageSound {
+    if case .default = sound {
+        return defaultCloudPeerNotificationSound
+    } else {
+        return sound
+    }
+}
+
+private func notificationsAndSoundsEntries(authorizationStatus: AccessType, warningSuppressed: Bool, globalSettings: GlobalNotificationSettingsSet, inAppSettings: InAppNotificationSettings, exceptions: (users: NotificationExceptionMode, groups: NotificationExceptionMode, channels: NotificationExceptionMode, stories: NotificationExceptionMode), presentationData: PresentationData, hasMoreThanOneAccount: Bool) -> [NotificationsAndSoundsEntry] {
+    var entries: [NotificationsAndSoundsEntry] = []
+    
+    if hasMoreThanOneAccount {
+        entries.append(.accountsHeader(presentationData.theme, presentationData.strings.NotificationSettings_ShowNotificationsFromAccountsSection))
+        entries.append(.allAccounts(presentationData.theme, presentationData.strings.NotificationSettings_ShowNotificationsAllAccounts, inAppSettings.displayNotificationsFromAllAccounts))
+        entries.append(.accountsInfo(presentationData.theme, inAppSettings.displayNotificationsFromAllAccounts ? presentationData.strings.NotificationSettings_ShowNotificationsAllAccountsInfoOn : presentationData.strings.NotificationSettings_ShowNotificationsAllAccountsInfoOff))
+    }
+    
+    if #available(iOSApplicationExtension 10.0, iOS 10.0, *) {
+        let title: String
+        let text: String
+        if case .unreachable = authorizationStatus {
+            title = presentationData.strings.Notifications_PermissionsUnreachableTitle
+            text = presentationData.strings.Notifications_PermissionsUnreachableText
+        } else {
+            title = presentationData.strings.Notifications_PermissionsTitle
+            text = presentationData.strings.Notifications_PermissionsText
+        }
+    
+        switch (authorizationStatus, warningSuppressed) {
+            case (.denied, _):
+                entries.append(.permissionInfo(presentationData.theme, title, text, true))
+                entries.append(.permissionEnable(presentationData.theme, presentationData.strings.Notifications_PermissionsAllowInSettings))
+            case (.unreachable, false):
+                entries.append(.permissionInfo(presentationData.theme, title, text, false))
+                entries.append(.permissionEnable(presentationData.theme, presentationData.strings.Notifications_PermissionsOpenSettings))
+            case (.notDetermined, _):
+                entries.append(.permissionInfo(presentationData.theme, title, text, true))
+                entries.append(.permissionEnable(presentationData.theme, presentationData.strings.Notifications_PermissionsAllow))
+            default:
+                break
+        }
+    }
+    
+    entries.append(.categoriesHeader(presentationData.theme, presentationData.strings.Notifications_MessageNotifications.uppercased()))
+    entries.append(.privateChats(presentationData.theme, presentationData.strings.Notifications_PrivateChats, !exceptions.users.isEmpty ? presentationData.strings.Notifications_CategoryExceptions(Int32(exceptions.users.peerIds.count)) : "", globalSettings.privateChats.enabled ? presentationData.strings.Notifications_On : presentationData.strings.Notifications_Off))
+    entries.append(.groupChats(presentationData.theme, presentationData.strings.Notifications_GroupChats, !exceptions.groups.isEmpty ? presentationData.strings.Notifications_CategoryExceptions(Int32(exceptions.groups.peerIds.count)) : "", globalSettings.groupChats.enabled ? presentationData.strings.Notifications_On : presentationData.strings.Notifications_Off))
+    entries.append(.channels(presentationData.theme, presentationData.strings.Notifications_Channels, !exceptions.channels.isEmpty ? presentationData.strings.Notifications_CategoryExceptions(Int32(exceptions.channels.peerIds.count)) : "", globalSettings.channels.enabled ? presentationData.strings.Notifications_On : presentationData.strings.Notifications_Off))
+    
+    let storiesValue: String
+    switch globalSettings.privateChats.storySettings.mute {
+    case .default:
+        storiesValue = presentationData.strings.Notifications_TopChats
+    case .muted:
+        storiesValue = presentationData.strings.Notifications_Off
+    case .unmuted:
+        storiesValue = presentationData.strings.Notifications_On
+    }
+    
+    entries.append(.stories(presentationData.theme, presentationData.strings.Notifications_Stories, !exceptions.stories.isEmpty ? presentationData.strings.Notifications_CategoryExceptions(Int32(exceptions.stories.peerIds.count)) : "", storiesValue))
+    
+    var reactionsValue: String = ""
+    var hasReactionNotifications = false
+    switch globalSettings.reactionSettings.messages {
+    case .nobody:
+        break
+    default:
+        if !reactionsValue.isEmpty {
+            reactionsValue.append(", ")
+        }
+        hasReactionNotifications = true
+        reactionsValue.append(presentationData.strings.Notifications_Reactions_SubtitleMessages)
+    }
+    switch globalSettings.reactionSettings.stories {
+    case .nobody:
+        break
+    default:
+        if !reactionsValue.isEmpty {
+            reactionsValue.append(", ")
+        }
+        hasReactionNotifications = true
+        reactionsValue.append(presentationData.strings.Notifications_Reactions_SubtitleStories)
+    }
+    entries.append(.reactions(presentationData.theme, presentationData.strings.Notifications_Reactions, reactionsValue, hasReactionNotifications ? presentationData.strings.Notifications_On : presentationData.strings.Notifications_Off))
+    
+    entries.append(.inAppHeader(presentationData.theme, presentationData.strings.Notifications_InAppNotifications.uppercased()))
+    entries.append(.inAppSounds(presentationData.theme, presentationData.strings.Notifications_InAppNotificationsSounds, inAppSettings.playSounds))
+    entries.append(.inAppVibrate(presentationData.theme, presentationData.strings.Notifications_InAppNotificationsVibrate, inAppSettings.vibrate))
+    entries.append(.inAppPreviews(presentationData.theme, presentationData.strings.Notifications_InAppNotificationsPreview, inAppSettings.displayPreviews))
+    
+    entries.append(.displayNamesOnLockscreen(presentationData.theme, presentationData.strings.Notifications_DisplayNamesOnLockScreen, inAppSettings.displayNameOnLockscreen))
+    entries.append(.displayNamesOnLockscreenInfo(presentationData.theme, presentationData.strings.Notifications_DisplayNamesOnLockScreenInfoWithLink))
+    
+    entries.append(.badgeHeader(presentationData.theme, presentationData.strings.Notifications_Badge.uppercased()))
+    
+    let counterTagSettings = CounterTagSettings(summaryTags: inAppSettings.totalUnreadCountIncludeTags)
+    
+    entries.append(.includeChannels(presentationData.theme, presentationData.strings.Notifications_Badge_IncludeChannels, counterTagSettings.contains(.channels)))
+    entries.append(.unreadCountCategory(presentationData.theme, presentationData.strings.Notifications_Badge_CountUnreadMessages, inAppSettings.totalUnreadCountDisplayCategory == .messages))
+    entries.append(.unreadCountCategoryInfo(presentationData.theme, inAppSettings.totalUnreadCountDisplayCategory == .chats ? presentationData.strings.Notifications_Badge_CountUnreadMessages_InfoOff : presentationData.strings.Notifications_Badge_CountUnreadMessages_InfoOn))
+    entries.append(.joinedNotifications(presentationData.theme, presentationData.strings.NotificationSettings_ContactJoined, globalSettings.contactsJoined))
+    entries.append(.joinedNotificationsInfo(presentationData.theme, presentationData.strings.NotificationSettings_ContactJoinedInfo))
+    
+    entries.append(.reset(presentationData.theme, presentationData.strings.Notifications_ResetAllNotifications))
+    entries.append(.resetNotice(presentationData.theme, presentationData.strings.Notifications_ResetAllNotificationsHelp))
+    
+    return entries
+}
+
+public func notificationsAndSoundsController(context: AccountContext, exceptionsList: NotificationExceptionsList?, focusOnItemTag: NotificationsAndSoundsEntryTag? = nil) -> ViewController {
+    var presentControllerImpl: ((ViewController, ViewControllerPresentationArguments?) -> Void)?
+    var pushControllerImpl: ((ViewController) -> Void)?
+    
+    let notificationExceptions: Promise<(users: NotificationExceptionMode, groups: NotificationExceptionMode, channels: NotificationExceptionMode, stories: NotificationExceptionMode)> = Promise()
+    
+    let updateNotificationExceptions:((users: NotificationExceptionMode, groups: NotificationExceptionMode, channels: NotificationExceptionMode, stories: NotificationExceptionMode)) -> Void = { value in
+        notificationExceptions.set(.single(value))
+    }
+    
+    let arguments = NotificationsAndSoundsArguments(context: context, presentController: { controller, arguments in
+        presentControllerImpl?(controller, arguments)
+    }, pushController: { controller in
+        pushControllerImpl?(controller)
+    }, soundSelectionDisposable: MetaDisposable(), authorizeNotifications: {
+        let _ = (DeviceAccess.authorizationStatus(applicationInForeground: context.sharedContext.applicationBindings.applicationInForeground, subject: .notifications)
+        |> take(1)
+        |> deliverOnMainQueue).start(next: { status in
+            switch status {
+                case .notDetermined:
+                    DeviceAccess.authorizeAccess(to: .notifications, registerForNotifications: { result in
+                        context.sharedContext.applicationBindings.registerForNotifications(result)
+                    })
+                case .denied, .restricted:
+                    context.sharedContext.applicationBindings.openSettings()
+                case .unreachable:
+                    ApplicationSpecificNotice.setPermissionWarning(accountManager: context.sharedContext.accountManager, permission: .notifications, value: Int32(Date().timeIntervalSince1970))
+                    context.sharedContext.applicationBindings.openSettings()
+                default:
+                    break
+            }
+        })
+    }, suppressWarning: {
+        let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+        presentControllerImpl?(textAlertController(context: context, title: presentationData.strings.Notifications_PermissionsSuppressWarningTitle, text: presentationData.strings.Notifications_PermissionsSuppressWarningText, actions: [TextAlertAction(type: .genericAction, title: presentationData.strings.Notifications_PermissionsKeepDisabled, action: {
+            ApplicationSpecificNotice.setPermissionWarning(accountManager: context.sharedContext.accountManager, permission: .notifications, value: Int32(Date().timeIntervalSince1970))
+        }), TextAlertAction(type: .defaultAction, title: presentationData.strings.Notifications_PermissionsEnable, action: {
+            context.sharedContext.applicationBindings.openSettings()
+        })]), nil)
+    }, openPeerCategory: { category in
+        _ = (notificationExceptions.get() |> take(1) |> deliverOnMainQueue).start(next: { (users, groups, channels, stories) in
+            let mode: NotificationExceptionMode
+            switch category {
+                case .privateChat:
+                    mode = users
+                case .group:
+                    mode = groups
+                case .channel:
+                    mode = channels
+                case .stories:
+                    mode = stories
+            }
+            pushControllerImpl?(notificationsPeerCategoryController(context: context, category: category, mode: mode, updatedMode: { mode in
+                _ = (notificationExceptions.get() |> take(1) |> deliverOnMainQueue).start(next: { (users, groups, channels, stories) in
+                    switch mode {
+                        case .users:
+                            updateNotificationExceptions((mode, groups, channels, stories))
+                        case .groups:
+                            updateNotificationExceptions((users, mode, channels, stories))
+                        case .channels:
+                            updateNotificationExceptions((users, groups, mode, stories))
+                        case .stories:
+                            updateNotificationExceptions((users, groups, channels, mode))
+                    }
+                })
+            }, focusOnItemTag: nil))
+        })
+    }, openReactions: {
+        pushControllerImpl?(reactionNotificationSettingsController(
+            context: context
+        ))
+    }, updateInAppSounds: { value in
+        let _ = updateInAppNotificationSettingsInteractively(accountManager: context.sharedContext.accountManager, { settings in
+            var settings = settings
+            settings.playSounds = value
+            return settings
+        }).start()
+    }, updateInAppVibration: { value in
+        let _ = updateInAppNotificationSettingsInteractively(accountManager: context.sharedContext.accountManager, { settings in
+            var settings = settings
+            settings.vibrate = value
+            return settings
+        }).start()
+    }, updateInAppPreviews: { value in
+        let _ = updateInAppNotificationSettingsInteractively(accountManager: context.sharedContext.accountManager, { settings in
+            var settings = settings
+            settings.displayPreviews = value
+            return settings
+        }).start()
+    }, updateDisplayNameOnLockscreen: { value in
+        let _ = updateInAppNotificationSettingsInteractively(accountManager: context.sharedContext.accountManager, { settings in
+            var settings = settings
+            settings.displayNameOnLockscreen = value
+            return settings
+        }).start()
+    }, updateIncludeTag: { tag, value in
+        let _ = updateInAppNotificationSettingsInteractively(accountManager: context.sharedContext.accountManager, { settings in
+            var currentSettings = CounterTagSettings(summaryTags: settings.totalUnreadCountIncludeTags)
+            if !value {
+                currentSettings.remove(tag)
+            } else {
+                currentSettings.insert(tag)
+            }
+            var settings = settings
+            settings.totalUnreadCountIncludeTags = currentSettings.toSumaryTags()
+            return settings
+        }).start()
+    }, updateTotalUnreadCountCategory: { value in
+        let _ = updateInAppNotificationSettingsInteractively(accountManager: context.sharedContext.accountManager, { settings in
+            var settings = settings
+            settings.totalUnreadCountDisplayCategory = value ? .messages : .chats
+            return settings
+        }).start()
+    }, resetNotifications: {
+        let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+        let actionSheet = ActionSheetController(presentationData: presentationData)
+        actionSheet.setItemGroups([ActionSheetItemGroup(items: [
+            ActionSheetTextItem(title: presentationData.strings.Notifications_ResetAllNotificationsText),
+            ActionSheetButtonItem(title: presentationData.strings.Notifications_Reset, color: .destructive, action: { [weak actionSheet] in
+                actionSheet?.dismissAnimated()
+                
+                let modifyPeers = context.engine.peers.resetAllPeerNotificationSettings()
+                let updateGlobal = updateGlobalNotificationSettingsInteractively(postbox: context.account.postbox, { _ in
+                    return GlobalNotificationSettingsSet.defaultSettings
+                })
+                let reset = resetPeerNotificationSettings(network: context.account.network)
+                let signal = combineLatest(modifyPeers, updateGlobal, reset)
+                let _ = signal.start()
+            })
+        ]), ActionSheetItemGroup(items: [
+            ActionSheetButtonItem(title: presentationData.strings.Common_Cancel, color: .accent, font: .bold, action: { [weak actionSheet] in
+                actionSheet?.dismissAnimated()
+            })
+        ])])
+        presentControllerImpl?(actionSheet, nil)
+    }, openAppSettings: {
+        context.sharedContext.applicationBindings.openSettings()
+    }, updateJoinedNotifications: { value in
+        let _ = updateGlobalNotificationSettingsInteractively(postbox: context.account.postbox, { settings in
+            var settings = settings
+            settings.contactsJoined = value
+            return settings
+        }).start()
+    }, updateNotificationsFromAllAccounts: { value in
+        let _ = updateInAppNotificationSettingsInteractively(accountManager: context.sharedContext.accountManager, { settings in
+            var settings = settings
+            settings.displayNotificationsFromAllAccounts = value
+            return settings
+        }).start()
+    })
+    
+    let sharedData = context.sharedContext.accountManager.sharedData(keys: [ApplicationSpecificSharedDataKeys.inAppNotificationSettings])
+    let preferences = context.account.postbox.preferencesView(keys: [PreferencesKeys.globalNotifications])
+    
+    let exceptionsSignal = Signal<NotificationExceptionsList?, NoError>.single(exceptionsList) |> then(context.engine.peers.notificationExceptionsList() |> map(Optional.init))
+    
+    let defaultStorySettings = PeerStoryNotificationSettings.default
+    
+    notificationExceptions.set(exceptionsSignal |> map { list -> (NotificationExceptionMode, NotificationExceptionMode, NotificationExceptionMode, NotificationExceptionMode) in
+        var users:[PeerId : NotificationExceptionWrapper] = [:]
+        var groups: [PeerId : NotificationExceptionWrapper] = [:]
+        var channels: [PeerId : NotificationExceptionWrapper] = [:]
+        var stories: [PeerId : NotificationExceptionWrapper] = [:]
+        if let list = list {
+            for (key, value) in list.settings {
+                if let peer = list.peers[key], !peer.debugDisplayTitle.isEmpty, peer.id != context.account.peerId {
+                    if value.storySettings != defaultStorySettings {
+                        stories[key] = NotificationExceptionWrapper(settings: value, peer: EnginePeer(peer))
+                    }
+                    
+                    switch value.muteState {
+                    case .default:
+                        switch value.messageSound {
+                        case .default:
+                            break
+                        default:
+                            switch key.namespace {
+                            case Namespaces.Peer.CloudUser:
+                                users[key] = NotificationExceptionWrapper(settings: value, peer: EnginePeer(peer))
+                            default:
+                                if let peer = peer as? TelegramChannel, case .broadcast = peer.info {
+                                    channels[key] = NotificationExceptionWrapper(settings: value, peer: .channel(peer))
+                                } else {
+                                    groups[key] = NotificationExceptionWrapper(settings: value, peer: EnginePeer(peer))
+                                }
+                            }
+                        }
+                    default:
+                        switch key.namespace {
+                        case Namespaces.Peer.CloudUser:
+                            users[key] = NotificationExceptionWrapper(settings: value, peer: EnginePeer(peer))
+                        default:
+                            if let peer = peer as? TelegramChannel, case .broadcast = peer.info {
+                                channels[key] = NotificationExceptionWrapper(settings: value, peer: .channel(peer))
+                            } else {
+                                groups[key] = NotificationExceptionWrapper(settings: value, peer: EnginePeer(peer))
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        
+        return (.users(users), .groups(groups), .channels(channels), .stories(stories))
+    })
+    
+    let notificationsWarningSuppressed = Promise<Bool>(true)
+    if #available(iOSApplicationExtension 10.0, iOS 10.0, *) {
+        notificationsWarningSuppressed.set(.single(true)
+        |> then(
+            context.sharedContext.accountManager.noticeEntry(key: ApplicationSpecificNotice.permissionWarningKey(permission: .notifications)!)
+            |> map { noticeView -> Bool in
+                let timestamp = noticeView.value.flatMap({ ApplicationSpecificNotice.getTimestampValue($0) })
+                if let timestamp = timestamp, timestamp > 0 {
+                    return true
+                } else {
+                    return false
+                }
+            }))
+    }
+    
+    let hasMoreThanOneAccount = context.sharedContext.activeAccountContexts
+    |> map { _, contexts, _ -> Bool in
+        return contexts.count > 1
+    }
+    |> distinctUntilChanged
+    
+    let signal = combineLatest(context.sharedContext.presentationData, sharedData, preferences, notificationExceptions.get(), DeviceAccess.authorizationStatus(applicationInForeground: context.sharedContext.applicationBindings.applicationInForeground, subject: .notifications), notificationsWarningSuppressed.get(), hasMoreThanOneAccount)
+        |> map { presentationData, sharedData, view, exceptions, authorizationStatus, warningSuppressed, hasMoreThanOneAccount -> (ItemListControllerState, (ItemListNodeState, Any)) in
+            
+            let viewSettings: GlobalNotificationSettingsSet
+            if let settings = view.values[PreferencesKeys.globalNotifications]?.get(GlobalNotificationSettings.self) {
+                viewSettings = settings.effective
+            } else {
+                viewSettings = GlobalNotificationSettingsSet.defaultSettings
+            }
+            
+            let inAppSettings: InAppNotificationSettings
+            if let settings = sharedData.entries[ApplicationSpecificSharedDataKeys.inAppNotificationSettings]?.get(InAppNotificationSettings.self) {
+                inAppSettings = settings
+            } else {
+                inAppSettings = InAppNotificationSettings.defaultSettings
+            }
+            
+            let entries = notificationsAndSoundsEntries(authorizationStatus: authorizationStatus, warningSuppressed: warningSuppressed, globalSettings: viewSettings, inAppSettings: inAppSettings, exceptions: exceptions, presentationData: presentationData, hasMoreThanOneAccount: hasMoreThanOneAccount)
+            
+            var index = 0
+            var scrollToItem: ListViewScrollToItem?
+            if let focusOnItemTag = focusOnItemTag {
+                for entry in entries {
+                    if entry.tag?.isEqual(to: focusOnItemTag) ?? false {
+                        scrollToItem = ListViewScrollToItem(index: index, position: .top(0.0), animated: false, curve: .Default(duration: 0.0), directionHint: .Up)
+                    }
+                    index += 1
+                }
+            }
+            
+            let controllerState = ItemListControllerState(presentationData: ItemListPresentationData(presentationData), title: .text(presentationData.strings.Notifications_Title), leftNavigationButton: nil, rightNavigationButton: nil, backNavigationButton: ItemListBackButton(title: presentationData.strings.Common_Back))
+            let listState = ItemListNodeState(presentationData: ItemListPresentationData(presentationData), entries: entries, style: .blocks, ensureVisibleItemTag: focusOnItemTag, initialScrollToItem: scrollToItem)
+            
+            return (controllerState, (listState, arguments))
+    }
+    
+    let controller = ItemListController(context: context, state: signal)
+    presentControllerImpl = { [weak controller] c, a in
+        controller?.present(c, in: .window(.root), with: a)
+    }
+    pushControllerImpl = { [weak controller] c in
+        (controller?.navigationController as? NavigationController)?.pushViewController(c)
+    }
+    return controller
+}

submodules/SettingsUI/Sources/Notifications/NotificationsCategoryItemListItem.swift

@@ -0,0 +1,454 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import TelegramPresentationData
+import ShimmerEffect
+import ItemListUI
+
+public class NotificationsCategoryItemListItem: ListViewItem, ItemListItem {
+    let presentationData: ItemListPresentationData
+    let systemStyle: ItemListSystemStyle
+    let icon: UIImage?
+    let title: String
+    let subtitle: String
+    let enabled: Bool
+    let label: String
+    public let sectionId: ItemListSectionId
+    let style: ItemListStyle
+    let action: (() -> Void)?
+    public let tag: ItemListItemTag?
+    public let shimmeringIndex: Int?
+    
+    public init(presentationData: ItemListPresentationData, systemStyle: ItemListSystemStyle = .glass, icon: UIImage? = nil, title: String, subtitle: String, enabled: Bool = true, label: String, sectionId: ItemListSectionId, style: ItemListStyle, action: (() -> Void)?, tag: ItemListItemTag? = nil, shimmeringIndex: Int? = nil) {
+        self.presentationData = presentationData
+        self.systemStyle = systemStyle
+        self.icon = icon
+        self.title = title
+        self.subtitle = subtitle
+        self.enabled = enabled
+        self.label = label
+        self.sectionId = sectionId
+        self.style = style
+        self.action = action
+        self.tag = tag
+        self.shimmeringIndex = shimmeringIndex
+    }
+    
+    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 = NotificationsCategoryItemListItemNode()
+            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? NotificationsCategoryItemListItemNode {
+                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)
+        
+        if self.enabled {
+            self.action?()
+        }
+    }
+}
+
+public class NotificationsCategoryItemListItemNode: ListViewItemNode, ItemListItemNode {
+    private let backgroundNode: ASDisplayNode
+    private let topStripeNode: ASDisplayNode
+    private let bottomStripeNode: ASDisplayNode
+    private let highlightedBackgroundNode: ASDisplayNode
+    private let maskNode: ASImageNode
+    
+    let iconNode: ASImageNode
+    let titleNode: TextNode
+    let subtitleNode: TextNode
+    let labelNode: TextNode
+    let arrowNode: ASImageNode
+    
+    private let activateArea: AccessibilityAreaNode
+    
+    private var item: NotificationsCategoryItemListItem?
+    
+    override public var canBeSelected: Bool {
+        if let item = self.item, let _ = item.action {
+            return true
+        } else {
+            return false
+        }
+    }
+    
+    public var tag: ItemListItemTag? {
+        return self.item?.tag
+    }
+
+    private var placeholderNode: ShimmerEffectNode?
+    private var absoluteLocation: (CGRect, CGSize)?
+    
+    public init() {
+        self.backgroundNode = ASDisplayNode()
+        self.backgroundNode.isLayerBacked = true
+        self.backgroundNode.backgroundColor = .white
+        
+        self.maskNode = ASImageNode()
+        
+        self.topStripeNode = ASDisplayNode()
+        self.topStripeNode.isLayerBacked = true
+        
+        self.bottomStripeNode = ASDisplayNode()
+        self.bottomStripeNode.isLayerBacked = true
+        
+        self.iconNode = ASImageNode()
+        self.iconNode.isLayerBacked = true
+        self.iconNode.displaysAsynchronously = false
+        
+        self.titleNode = TextNode()
+        self.titleNode.isUserInteractionEnabled = false
+        
+        self.subtitleNode = TextNode()
+        self.subtitleNode.isUserInteractionEnabled = false
+        
+        self.labelNode = TextNode()
+        self.labelNode.isUserInteractionEnabled = false
+        
+        self.arrowNode = ASImageNode()
+        self.arrowNode.displayWithoutProcessing = true
+        self.arrowNode.displaysAsynchronously = false
+        self.arrowNode.isLayerBacked = true
+        
+        self.highlightedBackgroundNode = ASDisplayNode()
+        self.highlightedBackgroundNode.isLayerBacked = true
+        
+        self.activateArea = AccessibilityAreaNode()
+        
+        super.init(layerBacked: false, dynamicBounce: false)
+        
+        self.addSubnode(self.titleNode)
+        self.addSubnode(self.subtitleNode)
+        self.addSubnode(self.labelNode)
+        self.addSubnode(self.arrowNode)
+        
+        self.addSubnode(self.activateArea)
+    }
+
+    override public func updateAbsoluteRect(_ rect: CGRect, within containerSize: CGSize) {
+        var rect = rect
+        rect.origin.y += self.insets.top
+        self.absoluteLocation = (rect, containerSize)
+        if let shimmerNode = self.placeholderNode {
+            shimmerNode.updateAbsoluteRect(rect, within: containerSize)
+        }
+    }
+    
+    public func asyncLayout() -> (_ item: NotificationsCategoryItemListItem, _ params: ListViewItemLayoutParams, _ insets: ItemListNeighbors) -> (ListViewItemNodeLayout, () -> Void) {
+        let makeTitleLayout = TextNode.asyncLayout(self.titleNode)
+        let makeSubtitleLayout = TextNode.asyncLayout(self.subtitleNode)
+        let makeLabelLayout = TextNode.asyncLayout(self.labelNode)
+        
+        let currentItem = self.item
+                
+        return { item, params, neighbors in
+            let rightInset = 34.0 + params.rightInset
+
+            var updateArrowImage: UIImage?
+            var updatedTheme: PresentationTheme?
+            
+            if currentItem?.presentationData.theme !== item.presentationData.theme {
+                updatedTheme = item.presentationData.theme
+                updateArrowImage = PresentationResourcesItemList.disclosureArrowImage(item.presentationData.theme)
+            }
+            
+            var updateIcon = false
+            if currentItem?.icon != item.icon {
+                updateIcon = true
+            }
+            
+            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
+            
+            var leftInset = 16.0 + params.leftInset
+            if let _ = item.icon {
+                leftInset += 43.0
+            }
+            
+            let titleFont = Font.regular(item.presentationData.fontSize.itemListBaseFontSize)
+            let titleColor = item.presentationData.theme.list.itemPrimaryTextColor
+            let detailFont = Font.regular(floor(item.presentationData.fontSize.itemListBaseFontSize * 15.0 / 17.0))
+            let detailColor = item.presentationData.theme.list.itemSecondaryTextColor
+            let labelFont = titleFont
+            let labelColor = item.presentationData.theme.list.itemSecondaryTextColor
+            
+            let (labelLayout, labelApply) = makeLabelLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: item.label, font: labelFont, textColor: labelColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: 60.0, height: CGFloat.greatestFiniteMagnitude), alignment: .natural, cutout: nil, insets: UIEdgeInsets()))
+            
+            let additionalTextRightInset: CGFloat = labelLayout.size.width
+           
+            let textConstrain = params.width - params.rightInset - 20.0 - leftInset - additionalTextRightInset
+            let (titleLayout, titleApply) = makeTitleLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: item.title, font: titleFont, textColor: titleColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: textConstrain, height: CGFloat.greatestFiniteMagnitude), alignment: .natural, cutout: nil, insets: UIEdgeInsets()))
+            
+            let (subtitleLayout, subtitleApply) = makeSubtitleLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: item.subtitle, font: detailFont, textColor: detailColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: textConstrain, height: CGFloat.greatestFiniteMagnitude), alignment: .natural, cutout: nil, insets: UIEdgeInsets()))
+                        
+            let verticalInset: CGFloat
+            switch item.systemStyle {
+            case .glass:
+                verticalInset = 15.0
+            case .legacy:
+                verticalInset = 11.0
+            }
+            
+            let titleSpacing: CGFloat = 1.0
+            
+            let height: CGFloat
+            if !item.subtitle.isEmpty {
+                height = verticalInset * 2.0 + titleLayout.size.height + titleSpacing + subtitleLayout.size.height
+            } else {
+                height = verticalInset * 2.0 + titleLayout.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.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 item.enabled {
+                        strongSelf.activateArea.accessibilityTraits = []
+                    } else {
+                        strongSelf.activateArea.accessibilityTraits = .notEnabled
+                    }
+                    
+                    if let icon = item.icon {
+                        if strongSelf.iconNode.supernode == nil {
+                            strongSelf.addSubnode(strongSelf.iconNode)
+                        }
+                        if updateIcon {
+                            strongSelf.iconNode.image = icon
+                        }
+                        let iconY = floorToScreenPixels((layout.contentSize.height - icon.size.height) / 2.0)
+                        strongSelf.iconNode.frame = CGRect(origin: CGPoint(x: params.leftInset + floor((leftInset - params.leftInset - icon.size.width) / 2.0), y: iconY), size: icon.size)
+                    } else if strongSelf.iconNode.supernode != nil {
+                        strongSelf.iconNode.image = nil
+                        strongSelf.iconNode.removeFromSupernode()
+                    }
+                    
+                    if let updateArrowImage = updateArrowImage {
+                        strongSelf.arrowNode.image = updateArrowImage
+                    }
+                    
+                    if let _ = updatedTheme {
+                        strongSelf.topStripeNode.backgroundColor = itemSeparatorColor
+                        strongSelf.bottomStripeNode.backgroundColor = itemSeparatorColor
+                        strongSelf.backgroundNode.backgroundColor = itemBackgroundColor
+                        strongSelf.highlightedBackgroundNode.backgroundColor = item.presentationData.theme.list.itemHighlightedBackgroundColor
+                    }
+                    
+                    let _ = titleApply()
+                    let _ = subtitleApply()
+                    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))
+                    }
+                    
+                    let titleFrame = CGRect(origin: CGPoint(x: leftInset, y: verticalInset), size: titleLayout.size)
+                    strongSelf.titleNode.frame = titleFrame
+                    
+                    let subtitleFrame = CGRect(origin: CGPoint(x: leftInset, y: titleFrame.maxY + titleSpacing), size: subtitleLayout.size)
+                    strongSelf.subtitleNode.frame = subtitleFrame
+
+                    let labelFrame = CGRect(origin: CGPoint(x: params.width - rightInset - labelLayout.size.width, y:  floorToScreenPixels((height - labelLayout.size.height) / 2.0)), size: labelLayout.size)
+                    strongSelf.labelNode.frame = labelFrame
+ 
+                    if let arrowImage = strongSelf.arrowNode.image {
+                        strongSelf.arrowNode.frame = CGRect(origin: CGPoint(x: params.width - params.rightInset - 7.0 - arrowImage.size.width, y: floorToScreenPixels((height - arrowImage.size.height) / 2.0)), size: arrowImage.size)
+                    }
+                    
+                    strongSelf.highlightedBackgroundNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -UIScreenPixel), size: CGSize(width: params.width, height: height + UIScreenPixel))
+
+                    if let shimmeringIndex = item.shimmeringIndex {
+                        let shimmerNode: ShimmerEffectNode
+                        if let current = strongSelf.placeholderNode {
+                            shimmerNode = current
+                        } else {
+                            shimmerNode = ShimmerEffectNode()
+                            strongSelf.placeholderNode = shimmerNode
+                            if strongSelf.backgroundNode.supernode != nil {
+                                strongSelf.insertSubnode(shimmerNode, aboveSubnode: strongSelf.backgroundNode)
+                            } else {
+                                strongSelf.addSubnode(shimmerNode)
+                            }
+                        }
+                        shimmerNode.frame = CGRect(origin: CGPoint(), size: contentSize)
+                        if let (rect, size) = strongSelf.absoluteLocation {
+                            shimmerNode.updateAbsoluteRect(rect, within: size)
+                        }
+
+                        var shapes: [ShimmerEffectNode.Shape] = []
+
+                        let titleLineWidth: CGFloat = (shimmeringIndex % 2 == 0) ? 120.0 : 80.0
+                        let lineDiameter: CGFloat = 8.0
+
+                        let titleFrame = strongSelf.titleNode.frame
+                        shapes.append(.roundedRectLine(startPoint: CGPoint(x: titleFrame.minX, y: titleFrame.minY + floor((titleFrame.height - lineDiameter) / 2.0)), width: titleLineWidth, diameter: lineDiameter))
+
+                        shimmerNode.update(backgroundColor: item.presentationData.theme.list.itemBlocksBackgroundColor, foregroundColor: item.presentationData.theme.list.mediaPlaceholderColor, shimmeringColor: item.presentationData.theme.list.itemBlocksBackgroundColor.withAlphaComponent(0.4), shapes: shapes, size: contentSize)
+                    } else if let shimmerNode = strongSelf.placeholderNode {
+                        strongSelf.placeholderNode = nil
+                        shimmerNode.removeFromSupernode()
+                    }
+                }
+            })
+        }
+    }
+    
+    override public func setHighlighted(_ highlighted: Bool, at point: CGPoint, animated: Bool) {
+        super.setHighlighted(highlighted, at: point, animated: animated)
+        
+        if highlighted && (self.item?.enabled ?? false) {
+            self.highlightedBackgroundNode.alpha = 1.0
+            if self.highlightedBackgroundNode.supernode == nil {
+                var anchorNode: ASDisplayNode?
+                if self.bottomStripeNode.supernode != nil {
+                    anchorNode = self.bottomStripeNode
+                } else if self.topStripeNode.supernode != nil {
+                    anchorNode = self.topStripeNode
+                } else if self.backgroundNode.supernode != nil {
+                    anchorNode = self.backgroundNode
+                }
+                if let anchorNode = anchorNode {
+                    self.insertSubnode(self.highlightedBackgroundNode, aboveSubnode: anchorNode)
+                } else {
+                    self.addSubnode(self.highlightedBackgroundNode)
+                }
+            }
+        } else {
+            if self.highlightedBackgroundNode.supernode != nil {
+                if animated {
+                    self.highlightedBackgroundNode.layer.animateAlpha(from: self.highlightedBackgroundNode.alpha, to: 0.0, duration: 0.4, completion: { [weak self] completed in
+                        if let strongSelf = self {
+                            if completed {
+                                strongSelf.highlightedBackgroundNode.removeFromSupernode()
+                            }
+                        }
+                        })
+                    self.highlightedBackgroundNode.alpha = 0.0
+                } else {
+                    self.highlightedBackgroundNode.removeFromSupernode()
+                }
+            }
+        }
+    }
+    
+    override public func animateInsertion(_ currentTimestamp: Double, duration: Double, options: ListViewItemAnimationOptions) {
+        self.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.4)
+    }
+    
+    override public func animateAdded(_ currentTimestamp: Double, duration: Double) {
+        self.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.2)
+    }
+    
+    override public func animateRemoved(_ currentTimestamp: Double, duration: Double) {
+        self.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.15, removeOnCompletion: false)
+    }
+}