Merge commit '7621e2f8dec938cf48181c8b10afc9b01f444e68' into beta

submodules/TelegramUI/Components/Settings/NewSessionInfoScreen/Sources/NewSessionInfoContentComponent.swift

@@ -0,0 +1,244 @@
+import Foundation
+import UIKit
+import Display
+import ComponentFlow
+import MultilineTextComponent
+import BalancedTextComponent
+import TelegramPresentationData
+import AppBundle
+import BundleIconComponent
+import Markdown
+import TelegramCore
+import LottieComponent
+
+public final class NewSessionInfoContentComponent: Component {
+    public let theme: PresentationTheme
+    public let strings: PresentationStrings
+    public let newSessionReview: NewSessionReview
+    
+    public init(
+        theme: PresentationTheme,
+        strings: PresentationStrings,
+        newSessionReview: NewSessionReview
+    ) {
+        self.theme = theme
+        self.strings = strings
+        self.newSessionReview = newSessionReview
+    }
+    
+    public static func ==(lhs: NewSessionInfoContentComponent, rhs: NewSessionInfoContentComponent) -> Bool {
+        if lhs.theme !== rhs.theme {
+            return false
+        }
+        if lhs.strings !== rhs.strings {
+            return false
+        }
+        if lhs.newSessionReview != rhs.newSessionReview {
+            return false
+        }
+        return true
+    }
+    
+    public final class View: UIView {
+        private let scrollView: UIScrollView
+        private let iconBackground: UIImageView
+        private let iconForeground = ComponentView<Empty>()
+        
+        private let notice = ComponentView<Empty>()
+        private let noticeBackground: SimpleLayer
+        
+        private let title = ComponentView<Empty>()
+        private let mainText = ComponentView<Empty>()
+        
+        private var component: NewSessionInfoContentComponent?
+        
+        public override init(frame: CGRect) {
+            self.scrollView = UIScrollView()
+            
+            self.noticeBackground = SimpleLayer()
+            self.noticeBackground.cornerRadius = 10.0
+            
+            self.iconBackground = 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.layer.addSublayer(self.noticeBackground)
+            self.scrollView.addSubview(self.iconBackground)
+        }
+        
+        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: NewSessionInfoContentComponent, availableSize: CGSize, state: EmptyComponentState, environment: Environment<Empty>, transition: ComponentTransition) -> CGSize {
+            self.component = component
+            
+            let sideInset: CGFloat = 16.0
+            let noticeInsetX: CGFloat = 16.0
+            let noticeInsetY: CGFloat = 12.0
+            
+            var contentHeight: CGFloat = 0.0
+            
+            contentHeight += -14.0
+            
+            let noticeSize = self.notice.update(
+                transition: .immediate,
+                component: AnyComponent(BalancedTextComponent(
+                    text: .plain(NSAttributedString(string: component.strings.SessionReview_NoticeText, font: Font.semibold(15.0), textColor: component.theme.list.itemDestructiveColor)),
+                    horizontalAlignment: .center,
+                    maximumNumberOfLines: 0,
+                    lineSpacing: 0.2
+                )),
+                environment: {},
+                containerSize: CGSize(width: availableSize.width - noticeInsetX * 2.0, height: 1000.0)
+            )
+            let noticeBackgroundFrame = CGRect(origin: CGPoint(x: 0.0, y: contentHeight), size: CGSize(width: availableSize.width, height: noticeSize.height + noticeInsetY * 2.0))
+            transition.setFrame(layer: self.noticeBackground, frame: noticeBackgroundFrame)
+            self.noticeBackground.backgroundColor = component.theme.list.itemDestructiveColor.withMultipliedAlpha(0.1).cgColor
+            
+            if let noticeView = self.notice.view {
+                if noticeView.superview == nil {
+                    self.scrollView.addSubview(noticeView)
+                }
+                transition.setFrame(view: noticeView, frame: CGRect(origin: CGPoint(x: noticeBackgroundFrame.minX + floor((noticeBackgroundFrame.width - noticeSize.width) * 0.5), y: noticeBackgroundFrame.minY + floor((noticeBackgroundFrame.height - noticeSize.height) * 0.5)), size: noticeSize))
+            }
+            contentHeight += noticeBackgroundFrame.height
+            contentHeight += 24.0
+            
+            let iconSize: CGFloat = 90.0
+            if self.iconBackground.image == nil {
+                let colors: NSArray = [component.theme.list.itemAccentColor.cgColor, component.theme.list.itemAccentColor.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)
+            
+            let iconForegroundSize = self.iconForeground.update(
+                transition: transition,
+                component: AnyComponent(LottieComponent(
+                    content: LottieComponent.AppBundleContent(name: "SessionReviewIcon"),
+                    color: .white
+                )),
+                environment: {},
+                containerSize: CGSize(width: 70.0, height: 70.0)
+            )
+            if let iconForegroundView = self.iconForeground.view as? LottieComponent.View {
+                if iconForegroundView.superview == nil {
+                    self.scrollView.addSubview(iconForegroundView)
+                    DispatchQueue.main.async {
+                        iconForegroundView.playOnce()
+                    }
+                }
+                transition.setFrame(view: iconForegroundView, frame: CGRect(origin: CGPoint(x: iconBackgroundFrame.minX + floor((iconBackgroundFrame.width - iconForegroundSize.width) * 0.5), y: iconBackgroundFrame.minY + floor((iconBackgroundFrame.height - iconForegroundSize.height) * 0.5)), size: iconForegroundSize))
+            }
+            
+            contentHeight += iconSize
+            contentHeight += 16.0
+            
+            let titleString = NSMutableAttributedString()
+            titleString.append(NSAttributedString(string: component.strings.SessionReview_Title, font: Font.semibold(19.0), textColor: component.theme.list.itemPrimaryTextColor))
+            let imageAttachment = NSTextAttachment()
+            imageAttachment.image = self.iconBackground.image
+            titleString.append(NSAttributedString(attachment: imageAttachment))
+            
+            let titleSize = self.title.update(
+                transition: .immediate,
+                component: AnyComponent(MultilineTextComponent(
+                    text: .plain(titleString),
+                    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 = component.strings.SessionReview_Text(component.newSessionReview.device, component.newSessionReview.location).string
+            
+            let mainText = NSMutableAttributedString()
+            mainText.append(parseMarkdownIntoAttributedString(text, attributes: MarkdownAttributes(
+                body: MarkdownAttributeSet(
+                    font: Font.regular(15.0),
+                    textColor: component.theme.list.itemPrimaryTextColor
+                ),
+                bold: MarkdownAttributeSet(
+                    font: Font.semibold(15.0),
+                    textColor: component.theme.list.itemPrimaryTextColor
+                ),
+                link: MarkdownAttributeSet(
+                    font: Font.regular(15.0),
+                    textColor: component.theme.list.itemAccentColor,
+                    additionalAttributes: [:]
+                ),
+                linkAttribute: { attributes in
+                    return ("URL", "")
+                }
+            )))
+            
+            let mainTextSize = self.mainText.update(
+                transition: .immediate,
+                component: AnyComponent(BalancedTextComponent(
+                    text: .plain(mainText),
+                    horizontalAlignment: .center,
+                    maximumNumberOfLines: 0,
+                    lineSpacing: 0.2
+                )),
+                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 += 1.0
+            
+            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: ComponentTransition) -> CGSize {
+        return view.update(component: self, availableSize: availableSize, state: state, environment: environment, transition: transition)
+    }
+}

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

@@ -0,0 +1,306 @@
+import Foundation
+import UIKit
+import Display
+import ComponentFlow
+import ViewControllerComponent
+import AccountContext
+import SheetComponent
+import ButtonComponent
+import TelegramCore
+import AnimatedTextComponent
+
+private final class NewSessionInfoSheetContentComponent: Component {
+    typealias EnvironmentType = ViewControllerComponentContainer.Environment
+    
+    let newSessionReview: NewSessionReview
+    let dismiss: () -> Void
+    
+    init(
+        newSessionReview: NewSessionReview,
+        dismiss: @escaping () -> Void
+    ) {
+        self.newSessionReview = newSessionReview
+        self.dismiss = dismiss
+    }
+    
+    static func ==(lhs: NewSessionInfoSheetContentComponent, rhs: NewSessionInfoSheetContentComponent) -> Bool {
+        return true
+    }
+    
+    final class View: UIView {
+        private let content = ComponentView<Empty>()
+        private let button = ComponentView<Empty>()
+        
+        private var remainingTimer: Int
+        private var timer: Foundation.Timer?
+        
+        private var component: NewSessionInfoSheetContentComponent?
+        private weak var state: EmptyComponentState?
+        
+        override init(frame: CGRect) {
+            self.remainingTimer = 5
+            
+            super.init(frame: frame)
+        }
+        
+        required init?(coder: NSCoder) {
+            fatalError("init(coder:) has not been implemented")
+        }
+        
+        deinit {
+            self.timer?.invalidate()
+        }
+        
+        func update(component: NewSessionInfoSheetContentComponent, availableSize: CGSize, state: EmptyComponentState, environment: Environment<EnvironmentType>, transition: ComponentTransition) -> CGSize {
+            if self.timer == nil {
+                self.timer = Foundation.Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true, block: { [weak self] _ in
+                    guard let self else {
+                        return
+                    }
+                    self.remainingTimer = max(0, self.remainingTimer - 1)
+                    if self.remainingTimer == 0 {
+                        self.timer?.invalidate()
+                    }
+                    self.state?.updated(transition: .immediate)
+                })
+            }
+            
+            let previousComponent = self.component
+            
+            self.component = component
+            self.state = state
+            
+            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(NewSessionInfoContentComponent(
+                    theme: environment.theme,
+                    strings: environment.strings,
+                    newSessionReview: component.newSessionReview
+                )),
+                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
+            
+            var buttonContents: [AnyComponentWithIdentity<Empty>] = []
+            buttonContents.append(AnyComponentWithIdentity(id: AnyHashable(0 as Int), component: AnyComponent(
+                Text(text: environment.strings.SessionReview_OkAction, font: Font.semibold(17.0), color: environment.theme.list.itemCheckColors.foregroundColor)
+            )))
+            if self.remainingTimer > 0 {
+                buttonContents.append(AnyComponentWithIdentity(id: AnyHashable(1 as Int), component: AnyComponent(
+                    AnimatedTextComponent(font: Font.with(size: 17.0, weight: .semibold, traits: .monospacedNumbers), color: environment.theme.list.itemCheckColors.foregroundColor.withMultipliedAlpha(0.5), items: [
+                        AnimatedTextComponent.Item(id: AnyHashable(0 as Int), content: .number(self.remainingTimer, minDigits: 0))
+                    ])
+                )))
+            }
+            var buttonTransition = transition
+            if transition.animation.isImmediate && previousComponent != nil {
+                buttonTransition = buttonTransition.withAnimation(.curve(duration: 0.2, curve: .easeInOut))
+            }
+            let buttonSize = self.button.update(
+                transition: buttonTransition,
+                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(
+                        HStack(buttonContents, spacing: 5.0)
+                    )),
+                    isEnabled: self.remainingTimer == 0,
+                    tintWhenDisabled: false,
+                    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: ComponentTransition) -> CGSize {
+        return view.update(component: self, availableSize: availableSize, state: state, environment: environment, transition: transition)
+    }
+}
+
+private final class NewSessionInfoScreenComponent: Component {
+    typealias EnvironmentType = ViewControllerComponentContainer.Environment
+    
+    let context: AccountContext
+    let newSessionReview: NewSessionReview
+    
+    init(
+        context: AccountContext,
+        newSessionReview: NewSessionReview
+    ) {
+        self.context = context
+        self.newSessionReview = newSessionReview
+    }
+    
+    static func ==(lhs: NewSessionInfoScreenComponent, rhs: NewSessionInfoScreenComponent) -> Bool {
+        if lhs.context !== rhs.context {
+            return false
+        }
+        if lhs.newSessionReview != rhs.newSessionReview {
+            return false
+        }
+        return true
+    }
+    
+    final class View: UIView {
+        private let sheet = ComponentView<(ViewControllerComponentContainer.Environment, SheetComponentEnvironment)>()
+        private let sheetAnimateOut = ActionSlot<Action<Void>>()
+        
+        private var component: NewSessionInfoScreenComponent?
+        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: NewSessionInfoScreenComponent, availableSize: CGSize, state: EmptyComponentState, environment: Environment<ViewControllerComponentContainer.Environment>, transition: ComponentTransition) -> 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(NewSessionInfoSheetContentComponent(
+                        newSessionReview: component.newSessionReview,
+                        dismiss: { [weak self] in
+                            guard let self else {
+                                return
+                            }
+                            self.sheetAnimateOut.invoke(Action { [weak self] _ in
+                                if let controller = environment.controller() {
+                                    controller.dismiss(completion: nil)
+                                }
+                                
+                                guard let self else {
+                                    return
+                                }
+                                let _ = self
+                                //self.component?.buttonAction?()
+                            })
+                        }
+                    )),
+                    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: ComponentTransition) -> CGSize {
+        return view.update(component: self, availableSize: availableSize, state: state, environment: environment, transition: transition)
+    }
+}
+
+public class NewSessionInfoScreen: ViewControllerComponentContainer {
+    public init(context: AccountContext, newSessionReview: NewSessionReview) {
+        super.init(context: context, component: NewSessionInfoScreenComponent(
+            context: context,
+            newSessionReview: newSessionReview
+        ), 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
+    }
+}