Stories

submodules/TelegramUI/Components/Settings/ArchiveInfoScreen/BUILD

@@ -0,0 +1,35 @@
+load("@build_bazel_rules_swift//swift:swift.bzl", "swift_library")
+
+swift_library(
+    name = "ArchiveInfoScreen",
+    module_name = "ArchiveInfoScreen",
+    srcs = glob([
+        "Sources/**/*.swift",
+    ]),
+    copts = [
+        "-warnings-as-errors",
+    ],
+    deps = [
+        "//submodules/AsyncDisplayKit",
+        "//submodules/Display",
+        "//submodules/Postbox",
+        "//submodules/TelegramCore",
+        "//submodules/SSignalKit/SwiftSignalKit",
+        "//submodules/ComponentFlow",
+        "//submodules/Components/ViewControllerComponent",
+        "//submodules/Components/ComponentDisplayAdapters",
+        "//submodules/Components/MultilineTextComponent",
+        "//submodules/TelegramPresentationData",
+        "//submodules/AccountContext",
+        "//submodules/AppBundle",
+        "//submodules/Components/SheetComponent",
+        "//submodules/PresentationDataUtils",
+        "//submodules/Components/SolidRoundedButtonComponent",
+        "//submodules/Components/BundleIconComponent",
+        "//submodules/TelegramUI/Components/ButtonComponent",
+        "//submodules/Markdown",
+    ],
+    visibility = [
+        "//visibility:public",
+    ],
+)

submodules/TelegramUI/Components/Settings/ArchiveInfoScreen/Sources/ArchiveInfoContentComponent.swift

@@ -0,0 +1,317 @@
+import Foundation
+import UIKit
+import Display
+import ComponentFlow
+import MultilineTextComponent
+import TelegramPresentationData
+import AppBundle
+import BundleIconComponent
+import Markdown
+import TelegramCore
+
+public final class ArchiveInfoContentComponent: Component {
+    public let theme: PresentationTheme
+    public let strings: PresentationStrings
+    public let settings: GlobalPrivacySettings
+    public let openSettings: () -> Void
+    
+    public init(
+        theme: PresentationTheme,
+        strings: PresentationStrings,
+        settings: GlobalPrivacySettings,
+        openSettings: @escaping () -> Void
+    ) {
+        self.theme = theme
+        self.strings = strings
+        self.settings = settings
+        self.openSettings = openSettings
+    }
+    
+    public static func ==(lhs: ArchiveInfoContentComponent, rhs: ArchiveInfoContentComponent) -> Bool {
+        if lhs.theme !== rhs.theme {
+            return false
+        }
+        if lhs.strings !== rhs.strings {
+            return false
+        }
+        if lhs.settings != rhs.settings {
+            return false
+        }
+        return true
+    }
+    
+    private final class Item {
+        let icon = ComponentView<Empty>()
+        let title = ComponentView<Empty>()
+        let text = ComponentView<Empty>()
+        
+        init() {
+        }
+    }
+    
+    public final class View: UIView {
+        private let scrollView: UIScrollView
+        private let iconBackground: UIImageView
+        private let iconForeground: UIImageView
+        
+        private let title = ComponentView<Empty>()
+        private let mainText = ComponentView<Empty>()
+        
+        private var items: [Item] = []
+        
+        private var component: ArchiveInfoContentComponent?
+        
+        public override init(frame: CGRect) {
+            self.scrollView = UIScrollView()
+            
+            self.iconBackground = UIImageView()
+            self.iconForeground = UIImageView()
+            
+            super.init(frame: frame)
+            
+            self.addSubview(self.scrollView)
+            
+            self.scrollView.delaysContentTouches = false
+            self.scrollView.contentInsetAdjustmentBehavior = .never
+            if #available(iOS 13.0, *) {
+                self.scrollView.automaticallyAdjustsScrollIndicatorInsets = false
+            }
+            self.scrollView.showsVerticalScrollIndicator = false
+            self.scrollView.showsHorizontalScrollIndicator = false
+            self.scrollView.alwaysBounceHorizontal = false
+            self.scrollView.scrollsToTop = false
+            self.scrollView.clipsToBounds = false
+            
+            self.scrollView.addSubview(self.iconBackground)
+            self.scrollView.addSubview(self.iconForeground)
+        }
+        
+        required init(coder: NSCoder) {
+            preconditionFailure()
+        }
+        
+        public override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
+            if let result = super.hitTest(point, with: event) {
+                return result
+            } else {
+                return nil
+            }
+        }
+        
+        func update(component: ArchiveInfoContentComponent, availableSize: CGSize, state: EmptyComponentState, environment: Environment<Empty>, transition: Transition) -> CGSize {
+            self.component = component
+            
+            let sideInset: CGFloat = 16.0
+            let sideIconInset: CGFloat = 40.0
+            
+            var contentHeight: CGFloat = 0.0
+            
+            let iconSize: CGFloat = 90.0
+            if self.iconBackground.image == nil {
+                let backgroundColors = component.theme.chatList.pinnedArchiveAvatarColor.backgroundColors.colors
+                let colors: NSArray = [backgroundColors.0.cgColor, backgroundColors.1.cgColor]
+                self.iconBackground.image = generateGradientFilledCircleImage(diameter: iconSize, colors: colors)
+            }
+            let iconBackgroundFrame = CGRect(origin: CGPoint(x: floor((availableSize.width - iconSize) * 0.5), y: contentHeight), size: CGSize(width: iconSize, height: iconSize))
+            transition.setFrame(view: self.iconBackground, frame: iconBackgroundFrame)
+            
+            if self.iconForeground.image == nil {
+                self.iconForeground.image = generateTintedImage(image: UIImage(bundleImageName: "Avatar/ArchiveAvatarIcon"), color: .white)
+            }
+            if let image = self.iconForeground.image {
+                transition.setFrame(view: self.iconForeground, frame: CGRect(origin: CGPoint(x: iconBackgroundFrame.minX + floor((iconBackgroundFrame.width - image.size.width) * 0.5), y: iconBackgroundFrame.minY + floor((iconBackgroundFrame.height - image.size.height) * 0.5)), size: image.size))
+            }
+            
+            contentHeight += iconSize
+            contentHeight += 15.0
+            
+            //TODO:localize
+            let titleSize = self.title.update(
+                transition: .immediate,
+                component: AnyComponent(MultilineTextComponent(
+                    text: .plain(NSAttributedString(string: "This is Your Archive", font: Font.semibold(19.0), textColor: component.theme.list.itemPrimaryTextColor)),
+                    maximumNumberOfLines: 1
+                )),
+                environment: {},
+                containerSize: CGSize(width: availableSize.width - sideInset * 2.0, height: 1000.0)
+            )
+            if let titleView = self.title.view {
+                if titleView.superview == nil {
+                    self.scrollView.addSubview(titleView)
+                }
+                transition.setFrame(view: titleView, frame: CGRect(origin: CGPoint(x: floor((availableSize.width - titleSize.width) * 0.5), y: contentHeight), size: titleSize))
+            }
+            contentHeight += titleSize.height
+            contentHeight += 16.0
+            
+            let text: String
+            if component.settings.keepArchivedUnmuted {
+                text = "Archived chats will remain in the Archive when you receive a new message. [Tap to change 〉]()"
+            } else {
+                text = "When you receive a new message, muted chats will remain in the Archive, while unmuted chats will be moved to Chats. [Tap to change 〉]()"
+            }
+            
+            //TODO:localize
+            let mainTextSize = self.mainText.update(
+                transition: .immediate,
+                component: AnyComponent(MultilineTextComponent(
+                    text: .markdown(text: text, attributes: MarkdownAttributes(
+                        body: MarkdownAttributeSet(
+                            font: Font.regular(15.0),
+                            textColor: component.theme.list.itemSecondaryTextColor
+                        ),
+                        bold: MarkdownAttributeSet(
+                            font: Font.semibold(15.0),
+                            textColor: component.theme.list.itemSecondaryTextColor
+                        ),
+                        link: MarkdownAttributeSet(
+                            font: Font.regular(15.0),
+                            textColor: component.theme.list.itemAccentColor,
+                            additionalAttributes: [:]
+                        ),
+                        linkAttribute: { attributes in
+                            return ("URL", "")
+                        }
+                    )),
+                    horizontalAlignment: .center,
+                    maximumNumberOfLines: 0,
+                    lineSpacing: 0.2,
+                    highlightColor: component.theme.list.itemAccentColor.withMultipliedAlpha(0.1),
+                    highlightAction: { attributes in
+                        if let _ = attributes[NSAttributedString.Key(rawValue: "URL")] {
+                            return NSAttributedString.Key(rawValue: "URL")
+                        } else {
+                            return nil
+                        }
+                    },
+                    tapAction: { [weak self] _, _ in
+                        guard let self, let component = self.component else {
+                            return
+                        }
+                        component.openSettings()
+                    }
+                )),
+                environment: {},
+                containerSize: CGSize(width: availableSize.width - sideInset * 2.0, height: 1000.0)
+            )
+            if let mainTextView = self.mainText.view {
+                if mainTextView.superview == nil {
+                    self.scrollView.addSubview(mainTextView)
+                }
+                transition.setFrame(view: mainTextView, frame: CGRect(origin: CGPoint(x: floor((availableSize.width - mainTextSize.width) * 0.5), y: contentHeight), size: mainTextSize))
+            }
+            contentHeight += mainTextSize.height
+            
+            contentHeight += 24.0
+            
+            struct ItemDesc {
+                var icon: String
+                var title: String
+                var text: String
+            }
+            let itemDescs: [ItemDesc] = [
+                ItemDesc(
+                    icon: "Chat List/Archive/IconArchived",
+                    title: "Archived Chats",
+                    text: "Move any chat into your Archive and back by swiping on it."
+                ),
+                ItemDesc(
+                    icon: "Chat List/Archive/IconHide",
+                    title: "Hiding Archive",
+                    text: "Hide the Archive from your Main screen by swiping on it."
+                ),
+                ItemDesc(
+                    icon: "Chat List/Archive/IconStories",
+                    title: "Stories",
+                    text: "Archive Stories from your contacts separately from chats with them."
+                )
+            ]
+            for i in 0 ..< itemDescs.count {
+                if i != 0 {
+                    contentHeight += 24.0
+                }
+                
+                let item: Item
+                if self.items.count > i {
+                    item = self.items[i]
+                } else {
+                    item = Item()
+                    self.items.append(item)
+                }
+                
+                let itemDesc = itemDescs[i]
+                
+                let iconSize = item.icon.update(
+                    transition: .immediate,
+                    component: AnyComponent(BundleIconComponent(
+                        name: itemDesc.icon,
+                        tintColor: component.theme.list.itemAccentColor
+                    )),
+                    environment: {},
+                    containerSize: CGSize(width: 100.0, height: 100.0)
+                )
+                let titleSize = item.title.update(
+                    transition: .immediate,
+                    component: AnyComponent(MultilineTextComponent(
+                        text: .plain(NSAttributedString(string: itemDesc.title, font: Font.semibold(15.0), textColor: component.theme.list.itemPrimaryTextColor)),
+                        maximumNumberOfLines: 0,
+                        lineSpacing: 0.2
+                    )),
+                    environment: {},
+                    containerSize: CGSize(width: availableSize.width - sideInset * 2.0 - sideIconInset, height: 1000.0)
+                )
+                let textSize = item.text.update(
+                    transition: .immediate,
+                    component: AnyComponent(MultilineTextComponent(
+                        text: .plain(NSAttributedString(string: itemDesc.text, font: Font.regular(15.0), textColor: component.theme.list.itemSecondaryTextColor)),
+                        maximumNumberOfLines: 0,
+                        lineSpacing: 0.18
+                    )),
+                    environment: {},
+                    containerSize: CGSize(width: availableSize.width - sideInset * 2.0 - sideIconInset, height: 1000.0)
+                )
+                
+                if let iconView = item.icon.view {
+                    if iconView.superview == nil {
+                        self.scrollView.addSubview(iconView)
+                    }
+                    transition.setFrame(view: iconView, frame: CGRect(origin: CGPoint(x: sideInset, y: contentHeight + 4.0), size: iconSize))
+                }
+                
+                if let titleView = item.title.view {
+                    if titleView.superview == nil {
+                        self.scrollView.addSubview(titleView)
+                    }
+                    transition.setFrame(view: titleView, frame: CGRect(origin: CGPoint(x: sideInset + sideIconInset, y: contentHeight), size: titleSize))
+                }
+                contentHeight += titleSize.height
+                contentHeight += 2.0
+                
+                if let textView = item.text.view {
+                    if textView.superview == nil {
+                        self.scrollView.addSubview(textView)
+                    }
+                    transition.setFrame(view: textView, frame: CGRect(origin: CGPoint(x: sideInset + sideIconInset, y: contentHeight), size: textSize))
+                }
+                contentHeight += textSize.height
+            }
+            
+            let contentSize = CGSize(width: availableSize.width, height: contentHeight)
+            let size = CGSize(width: availableSize.width, height: min(availableSize.height, contentSize.height))
+            if self.scrollView.bounds.size != size || self.scrollView.contentSize != contentSize {
+                self.scrollView.frame = CGRect(origin: CGPoint(), size: size)
+                self.scrollView.contentSize = contentSize
+            }
+            
+            return size
+        }
+    }
+    
+    public func makeView() -> View {
+        return View(frame: CGRect())
+    }
+    
+    public func update(view: View, availableSize: CGSize, state: EmptyComponentState, environment: Environment<Empty>, transition: Transition) -> CGSize {
+        return view.update(component: self, availableSize: availableSize, state: state, environment: environment, transition: transition)
+    }
+}

submodules/TelegramUI/Components/Settings/ArchiveInfoScreen/Sources/ArchiveInfoScreen.swift

@@ -0,0 +1,279 @@
+import Foundation
+import UIKit
+import Display
+import ComponentFlow
+import ViewControllerComponent
+import AccountContext
+import SheetComponent
+import ButtonComponent
+import TelegramCore
+
+private final class ArchiveInfoSheetContentComponent: Component {
+    typealias EnvironmentType = ViewControllerComponentContainer.Environment
+    
+    let settings: GlobalPrivacySettings
+    let openSettings: () -> Void
+    let dismiss: () -> Void
+    
+    init(
+        settings: GlobalPrivacySettings,
+        openSettings: @escaping () -> Void,
+        dismiss: @escaping () -> Void
+    ) {
+        self.settings = settings
+        self.openSettings = openSettings
+        self.dismiss = dismiss
+    }
+    
+    static func ==(lhs: ArchiveInfoSheetContentComponent, rhs: ArchiveInfoSheetContentComponent) -> Bool {
+        if lhs.settings != rhs.settings {
+            return false
+        }
+        return true
+    }
+    
+    final class View: UIView {
+        private let content = ComponentView<Empty>()
+        private let button = ComponentView<Empty>()
+        
+        private var component: ArchiveInfoSheetContentComponent?
+        
+        override init(frame: CGRect) {
+            super.init(frame: frame)
+        }
+        
+        required init?(coder: NSCoder) {
+            fatalError("init(coder:) has not been implemented")
+        }
+        
+        func update(component: ArchiveInfoSheetContentComponent, availableSize: CGSize, state: EmptyComponentState, environment: Environment<EnvironmentType>, transition: Transition) -> CGSize {
+            self.component = component
+            
+            let environment = environment[EnvironmentType.self].value
+            
+            let sideInset: CGFloat = 16.0
+            
+            var contentHeight: CGFloat = 0.0
+            contentHeight += 30.0
+            
+            let contentSize = self.content.update(
+                transition: transition,
+                component: AnyComponent(ArchiveInfoContentComponent(
+                    theme: environment.theme,
+                    strings: environment.strings,
+                    settings: component.settings,
+                    openSettings: component.openSettings
+                )),
+                environment: {},
+                containerSize: CGSize(width: availableSize.width - sideInset * 2.0, height: availableSize.height)
+            )
+            if let contentView = self.content.view {
+                if contentView.superview == nil {
+                    self.addSubview(contentView)
+                }
+                transition.setFrame(view: contentView, frame: CGRect(origin: CGPoint(x: sideInset, y: contentHeight), size: contentSize))
+            }
+            contentHeight += contentSize.height
+            contentHeight += 30.0
+            
+            //TODO:localize
+            let buttonSize = self.button.update(
+                transition: transition,
+                component: AnyComponent(ButtonComponent(
+                    background: ButtonComponent.Background(
+                        color: environment.theme.list.itemCheckColors.fillColor,
+                        foreground: environment.theme.list.itemCheckColors.foregroundColor,
+                        pressedColor: environment.theme.list.itemCheckColors.fillColor.withMultipliedAlpha(0.8)
+                    ),
+                    content: AnyComponentWithIdentity(id: AnyHashable(0 as Int), component: AnyComponent(
+                        Text(text: "Got it", font: Font.semibold(17.0), color: environment.theme.list.itemCheckColors.foregroundColor)
+                    )),
+                    isEnabled: true,
+                    displaysProgress: false,
+                    action: { [weak self] in
+                        guard let self, let component = self.component else {
+                            return
+                        }
+                        component.dismiss()
+                    }
+                )),
+                environment: {},
+                containerSize: CGSize(width: availableSize.width - sideInset * 2.0, height: 50.0)
+            )
+            let buttonFrame = CGRect(origin: CGPoint(x: sideInset, y: contentHeight), size: buttonSize)
+            if let buttonView = self.button.view {
+                if buttonView.superview == nil {
+                    self.addSubview(buttonView)
+                }
+                transition.setFrame(view: buttonView, frame: buttonFrame)
+            }
+            contentHeight += buttonSize.height
+            
+            if environment.safeInsets.bottom.isZero {
+                contentHeight += 16.0
+            } else {
+                contentHeight += environment.safeInsets.bottom + 14.0
+            }
+            
+            return CGSize(width: availableSize.width, height: contentHeight)
+        }
+    }
+    
+    func makeView() -> View {
+        return View(frame: CGRect())
+    }
+    
+    func update(view: View, availableSize: CGSize, state: EmptyComponentState, environment: Environment<EnvironmentType>, transition: Transition) -> CGSize {
+        return view.update(component: self, availableSize: availableSize, state: state, environment: environment, transition: transition)
+    }
+}
+
+private final class ArchiveInfoScreenComponent: Component {
+    typealias EnvironmentType = ViewControllerComponentContainer.Environment
+    
+    let context: AccountContext
+    let settings: GlobalPrivacySettings
+    
+    init(
+        context: AccountContext,
+        settings: GlobalPrivacySettings
+    ) {
+        self.context = context
+        self.settings = settings
+    }
+    
+    static func ==(lhs: ArchiveInfoScreenComponent, rhs: ArchiveInfoScreenComponent) -> Bool {
+        if lhs.context !== rhs.context {
+            return false
+        }
+        if lhs.settings != rhs.settings {
+            return false
+        }
+        return true
+    }
+    
+    final class View: UIView {
+        private let sheet = ComponentView<(ViewControllerComponentContainer.Environment, SheetComponentEnvironment)>()
+        private let sheetAnimateOut = ActionSlot<Action<Void>>()
+        
+        private var component: ArchiveInfoScreenComponent?
+        private var environment: EnvironmentType?
+        
+        override init(frame: CGRect) {
+            super.init(frame: frame)
+        }
+        
+        required init?(coder: NSCoder) {
+            fatalError("init(coder:) has not been implemented")
+        }
+        
+        func update(component: ArchiveInfoScreenComponent, availableSize: CGSize, state: EmptyComponentState, environment: Environment<ViewControllerComponentContainer.Environment>, transition: Transition) -> CGSize {
+            self.component = component
+            
+            let environment = environment[ViewControllerComponentContainer.Environment.self].value
+            self.environment = environment
+            
+            let sheetEnvironment = SheetComponentEnvironment(
+                isDisplaying: environment.isVisible,
+                isCentered: environment.metrics.widthClass == .regular,
+                hasInputHeight: !environment.inputHeight.isZero,
+                regularMetricsSize: CGSize(width: 430.0, height: 900.0),
+                dismiss: { [weak self] _ in
+                    guard let self, let environment = self.environment else {
+                        return
+                    }
+                    self.sheetAnimateOut.invoke(Action { _ in
+                        if let controller = environment.controller() {
+                            controller.dismiss(completion: nil)
+                        }
+                    })
+                }
+            )
+            let _ = self.sheet.update(
+                transition: transition,
+                component: AnyComponent(SheetComponent(
+                    content: AnyComponent(ArchiveInfoSheetContentComponent(
+                        settings: component.settings,
+                        openSettings: { [weak self] in
+                            guard let self, let component = self.component, let controller = self.environment?.controller() else {
+                                return
+                            }
+                            let context = component.context
+                            self.sheetAnimateOut.invoke(Action { [weak context, weak controller] _ in
+                                if let controller, let context {
+                                    if let navigationController = controller.navigationController as? NavigationController {
+                                        navigationController.pushViewController(context.sharedContext.makeArchiveSettingsController(context: context))
+                                    }
+                                    controller.dismiss(completion: nil)
+                                }
+                            })
+                        },
+                        dismiss: { [weak self] in
+                            guard let self else {
+                                return
+                            }
+                            self.sheetAnimateOut.invoke(Action { _ in
+                                if let controller = environment.controller() {
+                                    controller.dismiss(completion: nil)
+                                }
+                            })
+                        }
+                    )),
+                    backgroundColor: .color(environment.theme.list.plainBackgroundColor),
+                    animateOut: self.sheetAnimateOut
+                )),
+                environment: {
+                    environment
+                    sheetEnvironment
+                },
+                containerSize: availableSize
+            )
+            if let sheetView = self.sheet.view {
+                if sheetView.superview == nil {
+                    self.addSubview(sheetView)
+                }
+                transition.setFrame(view: sheetView, frame: CGRect(origin: CGPoint(), size: availableSize))
+            }
+            
+            return availableSize
+        }
+    }
+    
+    func makeView() -> View {
+        return View(frame: CGRect())
+    }
+    
+    func update(view: View, availableSize: CGSize, state: EmptyComponentState, environment: Environment<ViewControllerComponentContainer.Environment>, transition: Transition) -> CGSize {
+        return view.update(component: self, availableSize: availableSize, state: state, environment: environment, transition: transition)
+    }
+}
+
+public class ArchiveInfoScreen: ViewControllerComponentContainer {
+    public init(context: AccountContext, settings: GlobalPrivacySettings) {
+        super.init(context: context, component: ArchiveInfoScreenComponent(
+            context: context,
+            settings: settings
+        ), navigationBarAppearance: .none)
+        
+        self.statusBar.statusBarStyle = .Ignore
+        self.navigationPresentation = .flatModal
+        self.blocksBackgroundWhenInOverlay = true
+    }
+    
+    required public init(coder aDecoder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+    
+    deinit {
+    }
+    
+    override public func containerLayoutUpdated(_ layout: ContainerViewLayout, transition: ContainedViewLayoutTransition) {
+        super.containerLayoutUpdated(layout, transition: transition)
+    }
+    
+    override public func viewDidAppear(_ animated: Bool) {
+        super.viewDidAppear(animated)
+        
+        self.view.disablesInteractiveModalDismiss = true
+    }
+}