Merge commit '7621e2f8dec938cf48181c8b10afc9b01f444e68' into beta

submodules/TelegramUI/Components/AvatarEditorScreen/Sources/AvatarPreviewComponent.swift

@@ -0,0 +1,227 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import ComponentFlow
+import SwiftSignalKit
+import ViewControllerComponent
+import ComponentDisplayAdapters
+import TelegramPresentationData
+import AccountContext
+import TelegramCore
+import MultilineTextComponent
+import EmojiStatusComponent
+import Postbox
+import AnimatedStickerNode
+import TelegramAnimatedStickerNode
+import StickerResources
+import AvatarBackground
+
+final class AvatarPreviewComponent: Component {
+    typealias EnvironmentType = Empty
+    
+    let context: AccountContext
+    let background: AvatarBackground
+    let file: TelegramMediaFile?
+    let tapped: () -> Void
+    
+    init(
+        context: AccountContext,
+        background: AvatarBackground,
+        file: TelegramMediaFile?,
+        tapped: @escaping () -> Void
+    ) {
+        self.context = context
+        self.background = background
+        self.file = file
+        self.tapped = tapped
+    }
+    
+    static func ==(lhs: AvatarPreviewComponent, rhs: AvatarPreviewComponent) -> Bool {
+        if lhs.context !== rhs.context {
+            return false
+        }
+        if lhs.background != rhs.background {
+            return false
+        }
+        if lhs.file != rhs.file {
+            return false
+        }
+        return true
+    }
+    
+    final class View: UIView, UITextFieldDelegate {
+        private let imageView: UIImageView
+        
+        private let imageNode: TransformImageNode
+        private var animationNode: AnimatedStickerNode?
+        
+        private var component: AvatarPreviewComponent?
+        private weak var state: EmptyComponentState?
+        
+        private let stickerFetchedDisposable = MetaDisposable()
+        private let cachedDisposable = MetaDisposable()
+        
+        override init(frame: CGRect) {
+            self.imageView = UIImageView()
+            self.imageView.isUserInteractionEnabled = false
+            
+            self.imageNode = TransformImageNode()
+                        
+            super.init(frame: frame)
+            
+            self.disablesInteractiveModalDismiss = true
+            self.disablesInteractiveKeyboardGestureRecognizer = true
+            
+            self.addSubview(self.imageView)
+            
+            self.addSubnode(self.imageNode)
+            
+            self.addGestureRecognizer(UITapGestureRecognizer(target: self, action: #selector(self.tapped)))
+        }
+        
+        required init?(coder: NSCoder) {
+            fatalError("init(coder:) has not been implemented")
+        }
+        
+        deinit {
+            self.stickerFetchedDisposable.dispose()
+            self.cachedDisposable.dispose()
+        }
+        
+        @objc func tapped() {
+            self.animationNode?.playOnce()
+            self.component?.tapped()
+        }
+        
+        func update(component: AvatarPreviewComponent, availableSize: CGSize, state: EmptyComponentState, environment: Environment<EnvironmentType>, transition: ComponentTransition) -> CGSize {
+            let previousBackground = self.component?.background
+            
+            let hadFile = self.component?.file != nil
+            var fileUpdated = false
+            if self.component?.file?.fileId != component.file?.fileId {
+                fileUpdated = true
+            }
+            
+            self.component = component
+            self.state = state
+            
+            let size = CGSize(width: availableSize.width * 0.66, height: availableSize.width * 0.66)
+            
+            var dimensions: CGSize?
+            if let file = component.file, fileUpdated, let fileDimensions = file.dimensions?.cgSize {
+                dimensions = fileDimensions
+                
+                if !self.imageNode.isHidden && hadFile, let snapshotView = self.imageNode.view.snapshotContentTree() {
+                    self.imageNode.view.superview?.addSubview(snapshotView)
+                    
+                    snapshotView.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.2, removeOnCompletion: false)
+                    snapshotView.layer.animateScale(from: 1.0, to: 0.01, duration: 0.2, removeOnCompletion: false, completion: { [weak snapshotView] _ in
+                        snapshotView?.removeFromSuperview()
+                    })
+                }
+                
+                if let animationNode = self.animationNode {
+                    self.animationNode = nil
+                    
+                    animationNode.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.2, removeOnCompletion: false)
+                    animationNode.layer.animateScale(from: 1.0, to: 0.01, duration: 0.2, removeOnCompletion: false, completion: { [weak animationNode] _ in
+                        animationNode?.removeFromSupernode()
+                    })
+                }
+                
+                self.imageNode.isHidden = false
+                if file.isAnimatedSticker || file.isVideoSticker || file.mimeType == "video/webm" {
+                    if self.animationNode == nil {
+                        let animationNode = DefaultAnimatedStickerNodeImpl()
+                        animationNode.autoplay = false
+                        self.animationNode = animationNode
+                        animationNode.started = { [weak self] in
+                            self?.imageNode.isHidden = true
+                        }
+                        self.addSubnode(animationNode)
+                    }
+                    
+                    self.imageNode.setSignal(chatMessageAnimatedSticker(postbox: component.context.account.postbox, userLocation: .other, file: file, small: false, size: fileDimensions.aspectFitted(CGSize(width: 256.0, height: 256.0))))
+                    self.stickerFetchedDisposable.set(freeMediaFileResourceInteractiveFetched(account: component.context.account, userLocation: .other, fileReference: stickerPackFileReference(file), resource: file.resource).start())
+                } else {
+                    if let animationNode = self.animationNode {
+                        animationNode.visibility = false
+                        self.animationNode = nil
+                        animationNode.removeFromSupernode()
+                    }
+                    self.imageNode.setSignal(chatMessageSticker(account: component.context.account, userLocation: .other, file: file, small: false, synchronousLoad: false))
+                    self.stickerFetchedDisposable.set(freeMediaFileResourceInteractiveFetched(account: component.context.account, userLocation: .other, fileReference: stickerPackFileReference(file), resource: chatMessageStickerResource(file: file, small: false)).start())
+                }
+                
+                if fileUpdated && hadFile {
+                    self.imageNode.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.2)
+                    self.imageNode.layer.animateScale(from: 0.01, to: 1.0, duration: 0.2)
+                    if let animationNode = self.animationNode {
+                        animationNode.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.2)
+                        animationNode.layer.animateScale(from: 0.01, to: 1.0, duration: 0.2)
+                    }
+                }
+            }
+            
+            if let dimensions {
+                let imageSize = dimensions.aspectFitted(size)
+                self.imageNode.asyncLayout()(TransformImageArguments(corners: ImageCorners(), imageSize: imageSize, boundingSize: imageSize, intrinsicInsets: UIEdgeInsets()))()
+                self.imageNode.frame = CGRect(origin: CGPoint(x: floor((availableSize.width - imageSize.width) / 2.0), y: (availableSize.height - imageSize.height) / 2.0), size: imageSize)
+                
+                if let animationNode = self.animationNode {
+                    animationNode.frame = CGRect(origin: CGPoint(x: floor((availableSize.width - imageSize.width) / 2.0), y: (availableSize.height - imageSize.height) / 2.0), size: imageSize)
+                    animationNode.updateLayout(size: imageSize)
+                }
+                
+                if fileUpdated {
+                    self.updateVisibility()
+                }
+            }
+            
+            self.imageView.frame = CGRect(origin: .zero, size: availableSize)
+            if previousBackground != component.background {
+                if let _ = previousBackground, !transition.animation.isImmediate {
+                    UIView.transition(with: self.imageView, duration: 0.2, options: .transitionCrossDissolve, animations: {
+                        self.imageView.image = component.background.generateImage(size: availableSize)
+                    })
+                } else {
+                    self.imageView.image = component.background.generateImage(size: availableSize)
+                }
+                self.imageView.image = component.background.generateImage(size: availableSize)
+            }
+                                    
+            return availableSize
+        }
+        
+        private func updateVisibility() {
+            guard let component = self.component, let file = component.file else {
+                return
+            }
+            let dimensions = file.dimensions ?? PixelDimensions(width: 512, height: 512)
+            let fittedDimensions = dimensions.cgSize.aspectFitted(CGSize(width: 384.0, height: 384.0))
+            let source = AnimatedStickerResourceSource(account: component.context.account, resource: file.resource, isVideo: file.isVideoSticker || file.mimeType == "video/webm")
+            self.animationNode?.setup(source: source, width: Int(fittedDimensions.width), height: Int(fittedDimensions.height), playbackMode: .count(1), mode: .direct(cachePathPrefix: nil))
+            self.animationNode?.visibility = true
+                        
+            if let animationNode = self.animationNode as? DefaultAnimatedStickerNodeImpl {
+                if file.isCustomTemplateEmoji {
+                    animationNode.dynamicColor = .white
+                } else {
+                    animationNode.dynamicColor = nil
+                }
+            }
+            
+            self.cachedDisposable.set((source.cachedDataPath(width: 384, height: 384)
+            |> deliverOn(Queue.concurrentDefaultQueue())).start())
+        }
+    }
+
+    public func makeView() -> View {
+        return View(frame: CGRect())
+    }
+    
+    public func update(view: View, availableSize: CGSize, state: State, environment: Environment<EnvironmentType>, transition: ComponentTransition) -> CGSize {
+        return view.update(component: self, availableSize: availableSize, state: state, environment: environment, transition: transition)
+    }
+}

submodules/TelegramUI/Components/AvatarEditorScreen/Sources/BackgroundColorComponent.swift

@@ -0,0 +1,408 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import ComponentFlow
+import ViewControllerComponent
+import ComponentDisplayAdapters
+import TelegramPresentationData
+import AvatarBackground
+
+final class BackgroundColorComponent: Component {
+    let theme: PresentationTheme
+    let isPremium: Bool
+    let values: [AvatarBackground]
+    let selectedValue: AvatarBackground
+    let customValue: AvatarBackground?
+    let updateValue: (AvatarBackground) -> Void
+    let openColorPicker: () -> Void
+    
+    init(
+        theme: PresentationTheme,
+        isPremium: Bool,
+        values: [AvatarBackground],
+        selectedValue: AvatarBackground,
+        customValue: AvatarBackground?,
+        updateValue: @escaping (AvatarBackground) -> Void,
+        openColorPicker: @escaping () -> Void
+    ) {
+        self.theme = theme
+        self.isPremium = isPremium
+        self.values = values
+        self.selectedValue = selectedValue
+        self.customValue = customValue
+        self.updateValue = updateValue
+        self.openColorPicker = openColorPicker
+    }
+    
+    static func ==(lhs: BackgroundColorComponent, rhs: BackgroundColorComponent) -> Bool {
+        if lhs.theme !== rhs.theme {
+            return false
+        }
+        if lhs.isPremium != rhs.isPremium {
+            return false
+        }
+        if lhs.values != rhs.values {
+            return false
+        }
+        if lhs.selectedValue != rhs.selectedValue {
+            return false
+        }
+        if lhs.customValue != rhs.customValue {
+            return false
+        }
+        return true
+    }
+    
+    class View: UIView, UIScrollViewDelegate {
+        private var views: [AnyHashable: ComponentView<Empty>] = [:]
+        private var scrollView: UIScrollView
+        
+        private var component: BackgroundColorComponent?
+        private weak var state: EmptyComponentState?
+        
+        override init(frame: CGRect) {
+            self.scrollView = UIScrollView()
+            self.scrollView.contentInsetAdjustmentBehavior = .never
+            self.scrollView.showsHorizontalScrollIndicator = false
+            self.scrollView.showsVerticalScrollIndicator = false
+            
+            super.init(frame: frame)
+                        
+            self.clipsToBounds = true
+            
+            self.scrollView.delegate = self
+            self.addSubview(self.scrollView)
+            
+            self.scrollView.disablesInteractiveTransitionGestureRecognizer = true
+        }
+        
+        required init?(coder: NSCoder) {
+            fatalError("init(coder:) has not been implemented")
+        }
+        
+        func scrollViewDidScroll(_ scrollView: UIScrollView) {
+            self.updateScrolling(transition: .immediate)
+        }
+        
+        func updateScrolling(transition: ComponentTransition) {
+            guard let component = self.component else {
+                return
+            }
+            
+            let itemSize = CGSize(width: 30.0, height: 30.0)
+            let sideInset: CGFloat = 12.0
+            let spacing: CGFloat = 13.0
+            
+            var values: [(AvatarBackground?, Bool)] = component.values.map { ($0, false) }
+            if let customValue = component.customValue {
+                values.append((customValue, true))
+            } else {
+                values.append((nil, true))
+            }
+            
+            let visibleBounds = self.scrollView.bounds.insetBy(dx: 0.0, dy: -10.0)
+            
+            var validIds: [AnyHashable] = []
+            for i in 0 ..< values.count {
+                let position: CGFloat = sideInset + (spacing + itemSize.width) * CGFloat(i)
+                let itemFrame = CGRect(origin: CGPoint(x: position, y: 11.0), size: itemSize)
+                var isVisible = false
+                if visibleBounds.intersects(itemFrame) {
+                    isVisible = true
+                }
+                if isVisible {
+                    let itemId = AnyHashable(i)
+                    validIds.append(itemId)
+                    
+                    let view: ComponentView<Empty>
+                    if let current = self.views[itemId] {
+                        view = current
+                    } else {
+                        view = ComponentView<Empty>()
+                        self.views[itemId] = view
+                    }
+                    
+                    let _ = view.update(
+                        transition: transition,
+                        component: AnyComponent(
+                            BackgroundSwatchComponent(
+                                theme: component.theme,
+                                background: values[i].0,
+                                isCustom: values[i].1,
+                                isSelected: component.selectedValue == values[i].0,
+                                isLocked: i >= 7 && !values[i].1 && !component.isPremium,
+                                action: {
+                                    if let value = values[i].0, component.selectedValue != value {
+                                        component.updateValue(value)
+                                    } else if values[i].1 {
+                                        component.openColorPicker()
+                                    }
+                                }
+                            )
+                        ),
+                        environment: {},
+                        containerSize: itemSize
+                    )
+                    if let itemView = view.view {
+                        if itemView.superview == nil {
+                            self.scrollView.addSubview(itemView)
+                        }
+                        transition.setFrame(view: itemView, frame: itemFrame)
+                    }
+                }
+            }
+        
+            var removeIds: [AnyHashable] = []
+            for (id, item) in self.views {
+                if !validIds.contains(id) {
+                    removeIds.append(id)
+                    if let itemView = item.view {
+                        itemView.removeFromSuperview()
+                    }
+                }
+            }
+            for id in removeIds {
+                self.views.removeValue(forKey: id)
+            }
+        }
+        
+        func update(component: BackgroundColorComponent, availableSize: CGSize, state: EmptyComponentState, environment: Environment<Empty>, transition: ComponentTransition) -> CGSize {
+            self.component = component
+            self.state = state
+            
+            let height: CGFloat = 52.0
+            let size = CGSize(width: availableSize.width, height: height)
+            let scrollFrame = CGRect(origin: .zero, size: size)
+            
+            let itemSize = CGSize(width: 30.0, height: 30.0)
+            let sideInset: CGFloat = 12.0
+            let spacing: CGFloat = 13.0
+            
+            let count = component.values.count + 1
+            let contentSize = CGSize(width: sideInset * 2.0 + CGFloat(count) * itemSize.width + CGFloat(count - 1) * spacing, height: height)
+            
+            if self.scrollView.frame != scrollFrame {
+                self.scrollView.frame = scrollFrame
+            }
+            if self.scrollView.contentSize != contentSize {
+                self.scrollView.contentSize = contentSize
+            }
+
+            self.updateScrolling(transition: .immediate)
+                        
+            return size
+        }
+    }
+    
+    func makeView() -> View {
+        return View(frame: CGRect())
+    }
+    
+    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)
+    }
+}
+
+private func generateAddIcon(color: UIColor) -> UIImage? {
+    return generateImage(CGSize(width: 30.0, height: 30.0), contextGenerator: { size, context in
+        context.clear(CGRect(origin: .zero, size: size))
+        context.setStrokeColor(color.cgColor)
+        context.setLineWidth(2.0)
+        context.setLineCap(.round)
+        
+        context.move(to: CGPoint(x: 15.0, y: 9.0))
+        context.addLine(to: CGPoint(x: 15.0, y: 21.0))
+        context.strokePath()
+        
+        context.move(to: CGPoint(x: 9.0, y: 15.0))
+        context.addLine(to: CGPoint(x: 21.0, y: 15.0))
+        context.strokePath()
+    })
+}
+
+private func generateMoreIcon() -> UIImage? {
+    return generateImage(CGSize(width: 30.0, height: 30.0), contextGenerator: { size, context in
+        context.clear(CGRect(origin: .zero, size: size))
+        context.setFillColor(UIColor.white.cgColor)
+               
+        context.addEllipse(in: CGRect(x: 8.5, y: 13.5, width: 3.0, height: 3.0))
+        context.fillPath()
+        
+        context.addEllipse(in: CGRect(x: 13.5, y: 13.5, width: 3.0, height: 3.0))
+        context.fillPath()
+        
+        context.addEllipse(in: CGRect(x: 18.5, y: 13.5, width: 3.0, height: 3.0))
+        context.fillPath()
+    })
+}
+
+private var lockIcon: UIImage? = {
+    let icon = generateTintedImage(image: UIImage(bundleImageName: "Chat/Stickers/SmallLock"), color: .white)
+    return generateImage(CGSize(width: 30.0, height: 30.0), contextGenerator: { size, context in
+        context.clear(CGRect(origin: .zero, size: size))
+        if let icon, let cgImage = icon.cgImage {
+            context.draw(cgImage, in: CGRect(origin: CGPoint(x: floorToScreenPixels((size.width - icon.size.width) / 2.0), y: floorToScreenPixels((size.height - icon.size.height) / 2.0)), size: icon.size), byTiling: false)
+        }
+    })
+}()
+
+final class BackgroundSwatchComponent: Component {
+    let theme: PresentationTheme
+    let background: AvatarBackground?
+    let isCustom: Bool
+    let isSelected: Bool
+    let isLocked: Bool
+    let action: () -> Void
+    
+    init(
+        theme: PresentationTheme,
+        background: AvatarBackground?,
+        isCustom: Bool,
+        isSelected: Bool,
+        isLocked: Bool,
+        action: @escaping () -> Void
+    ) {
+        self.theme = theme
+        self.background = background
+        self.isCustom = isCustom
+        self.isSelected = isSelected
+        self.isLocked = isLocked
+        self.action = action
+    }
+    
+    static func == (lhs: BackgroundSwatchComponent, rhs: BackgroundSwatchComponent) -> Bool {
+        return lhs.theme === rhs.theme && lhs.background == rhs.background && lhs.isCustom == rhs.isCustom && lhs.isSelected == rhs.isSelected && lhs.isLocked == rhs.isLocked
+    }
+    
+    final class View: UIButton {
+        private var component: BackgroundSwatchComponent?
+        
+        private let maskLayer: SimpleLayer
+        private let ringMaskLayer: SimpleShapeLayer
+        private let circleMaskLayer: SimpleShapeLayer
+        
+        private let iconLayer: SimpleLayer
+        
+        private var currentIsHighlighted: Bool = false {
+            didSet {
+                if self.currentIsHighlighted != oldValue {
+                    self.alpha = self.currentIsHighlighted ? 0.6 : 1.0
+                }
+            }
+        }
+                
+        override init(frame: CGRect) {
+            self.maskLayer = SimpleLayer()
+            self.ringMaskLayer = SimpleShapeLayer()
+            self.circleMaskLayer = SimpleShapeLayer()
+            self.iconLayer = SimpleLayer()
+          
+            super.init(frame: frame)
+            
+            self.addTarget(self, action: #selector(self.pressed), for: .touchUpInside)
+        }
+        
+        required init?(coder: NSCoder) {
+            fatalError("init(coder:) has not been implemented")
+        }
+        
+        @objc private func pressed() {
+            self.component?.action()
+        }
+        
+        override public func beginTracking(_ touch: UITouch, with event: UIEvent?) -> Bool {
+            self.currentIsHighlighted = true
+                
+            return super.beginTracking(touch, with: event)
+        }
+        
+        override public func endTracking(_ touch: UITouch?, with event: UIEvent?) {
+            self.currentIsHighlighted = false
+        
+            super.endTracking(touch, with: event)
+        }
+        
+        override public func cancelTracking(with event: UIEvent?) {
+            self.currentIsHighlighted = false
+
+            super.cancelTracking(with: event)
+        }
+        
+        func update(component: BackgroundSwatchComponent, availableSize: CGSize, state: EmptyComponentState, environment: Environment<Empty>, transition: ComponentTransition) -> CGSize {
+            let previousBackground = self.component?.background
+            self.component = component
+            
+            let contentSize = availableSize
+            let bounds = CGRect(origin: .zero, size: contentSize)
+  
+            self.layer.allowsGroupOpacity = true
+            
+            if self.layer.mask == nil {
+                self.layer.mask = self.maskLayer
+                self.maskLayer.frame = bounds
+                
+                self.maskLayer.addSublayer(self.circleMaskLayer)
+                self.maskLayer.addSublayer(self.ringMaskLayer)
+                
+                self.circleMaskLayer.frame = bounds
+                if self.circleMaskLayer.path == nil {
+                    self.circleMaskLayer.path = UIBezierPath(ovalIn: bounds.insetBy(dx: 3.0, dy: 3.0)).cgPath
+                }
+                
+                let ringFrame = bounds
+                self.ringMaskLayer.frame = CGRect(origin: .zero, size: ringFrame.size)
+                self.ringMaskLayer.strokeColor = UIColor.white.cgColor
+                self.ringMaskLayer.fillColor = UIColor.clear.cgColor
+                self.ringMaskLayer.lineWidth = 2.0 - UIScreenPixel
+                self.ringMaskLayer.path = UIBezierPath(ovalIn: CGRect(origin: .zero, size: ringFrame.size).insetBy(dx: 1.0, dy: 1.0)).cgPath
+                
+                self.layer.addSublayer(self.iconLayer)
+            }
+            
+            self.iconLayer.frame = bounds
+            if component.isCustom {
+                if previousBackground != component.background || self.iconLayer.contents == nil {
+                    if component.background != nil {
+                        self.iconLayer.contents = generateMoreIcon()?.cgImage
+                    } else {
+                        self.iconLayer.contents = generateAddIcon(color: component.theme.list.itemAccentColor)?.cgImage
+                    }
+                }
+            } else if component.isLocked {
+                self.iconLayer.contents = lockIcon?.cgImage
+            } else {
+                self.iconLayer.contents = nil
+            }
+            
+            if component.isSelected {
+                transition.setShapeLayerPath(layer: self.circleMaskLayer, path: CGPath(ellipseIn: bounds.insetBy(dx: 3.0, dy: 3.0), transform: nil))
+            } else {
+                transition.setShapeLayerPath(layer: self.circleMaskLayer, path: CGPath(ellipseIn: bounds, transform: nil))
+            }
+            
+            if previousBackground != component.background {
+                if let background = component.background {
+                    self.layer.backgroundColor = nil
+                    self.layer.contents = background.generateImage(size: availableSize).cgImage
+                } else {
+                    self.layer.backgroundColor = component.theme.list.itemAccentColor.withAlphaComponent(0.1).cgColor
+                    self.layer.contents = nil
+                }
+            } else if component.background == nil {
+                self.layer.backgroundColor = component.theme.list.itemAccentColor.withAlphaComponent(0.1).cgColor
+                self.layer.contents = nil
+            }
+
+            return availableSize
+        }
+    }
+    
+    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/AvatarEditorScreen/Sources/PremiumAlertController.swift

@@ -0,0 +1,272 @@
+import Foundation
+import UIKit
+import SwiftSignalKit
+import AsyncDisplayKit
+import Display
+import ComponentFlow
+import Postbox
+import TelegramCore
+import TelegramPresentationData
+import TelegramUIPreferences
+import AccountContext
+import AppBundle
+import PremiumStarComponent
+
+private final class PremiumAlertContentNode: AlertContentNode {
+    private let strings: PresentationStrings
+    private let presentationTheme: PresentationTheme
+    private let title: String?
+    private let text: String
+    
+    private let titleNode: ASTextNode
+    private let textNode: ASTextNode
+    private let icon = ComponentView<Empty>()
+    
+    private let actionNodesSeparator: ASDisplayNode
+    private let actionNodes: [TextAlertContentActionNode]
+    private let actionVerticalSeparators: [ASDisplayNode]
+    
+    private var validLayout: CGSize?
+    
+    override var dismissOnOutsideTap: Bool {
+        return self.isUserInteractionEnabled
+    }
+    
+    init(
+        theme: AlertControllerTheme,
+        presentationTheme: PresentationTheme,
+        strings: PresentationStrings,
+        title: String?,
+        text: String,
+        actions: [TextAlertAction]
+    ) {
+        self.strings = strings
+        self.presentationTheme = presentationTheme
+        self.title = title
+        self.text = text
+        
+        self.titleNode = ASTextNode()
+        self.titleNode.maximumNumberOfLines = 2
+        
+        self.textNode = ASTextNode()
+        self.textNode.maximumNumberOfLines = 0
+        self.textNode.lineSpacing = 0.1
+        
+        self.actionNodesSeparator = ASDisplayNode()
+        self.actionNodesSeparator.isLayerBacked = true
+        
+        self.actionNodes = actions.map { action -> TextAlertContentActionNode in
+            return TextAlertContentActionNode(theme: theme, action: action)
+        }
+        
+        var actionVerticalSeparators: [ASDisplayNode] = []
+        if actions.count > 1 {
+            for _ in 0 ..< actions.count - 1 {
+                let separatorNode = ASDisplayNode()
+                separatorNode.isLayerBacked = true
+                actionVerticalSeparators.append(separatorNode)
+            }
+        }
+        self.actionVerticalSeparators = actionVerticalSeparators
+        
+        super.init()
+        
+        self.addSubnode(self.titleNode)
+        self.addSubnode(self.textNode)
+        
+        self.addSubnode(self.actionNodesSeparator)
+        
+        for actionNode in self.actionNodes {
+            self.addSubnode(actionNode)
+        }
+        
+        for separatorNode in self.actionVerticalSeparators {
+            self.addSubnode(separatorNode)
+        }
+        
+        self.updateTheme(theme)
+    }
+    
+    override func updateTheme(_ theme: AlertControllerTheme) {
+        self.titleNode.attributedText = NSAttributedString(string: self.title ?? self.strings.PremiumNeeded_Title, font: Font.bold(17.0), textColor: theme.primaryColor, paragraphAlignment: .center)
+        self.textNode.attributedText = NSAttributedString(string: self.text, font: Font.regular(13.0), textColor: theme.primaryColor, paragraphAlignment: .center)
+        
+        self.actionNodesSeparator.backgroundColor = theme.separatorColor
+        for actionNode in self.actionNodes {
+            actionNode.updateTheme(theme)
+        }
+        for separatorNode in self.actionVerticalSeparators {
+            separatorNode.backgroundColor = theme.separatorColor
+        }
+        
+        if let size = self.validLayout {
+            _ = self.updateLayout(size: size, transition: .immediate)
+        }
+    }
+    
+    override func updateLayout(size: CGSize, transition: ContainedViewLayoutTransition) -> CGSize {
+        var size = size
+        size.width = min(size.width , 270.0)
+        
+        self.validLayout = size
+        
+        var origin: CGPoint = CGPoint(x: 0.0, y: 20.0)
+        
+        let starHeight: CGFloat = 105.0
+        let starSize = self.icon.update(
+            transition: .immediate,
+            component: AnyComponent(
+                PremiumStarComponent(
+                    theme: self.presentationTheme,
+                    isIntro: false,
+                    isVisible: true,
+                    hasIdleAnimations: true,
+                    colors: [
+                        UIColor(rgb: 0x6a94ff),
+                        UIColor(rgb: 0x9472fd),
+                        UIColor(rgb: 0xe26bd3)
+                    ]
+                )
+            ),
+            environment: {},
+            containerSize: CGSize(width: size.width, height: 200.0)
+        )
+        if let view = self.icon.view {
+            if view.superview == nil {
+                self.view.addSubview(view)
+            }
+            view.frame = CGRect(origin: CGPoint(x: 0.0, y: -36.0), size: starSize)
+            origin.y += starHeight
+        }
+        
+        let titleSize = self.titleNode.measure(size)
+        transition.updateFrame(node: self.titleNode, frame: CGRect(origin: CGPoint(x: floorToScreenPixels((size.width - titleSize.width) / 2.0), y: origin.y), size: titleSize))
+        origin.y += titleSize.height + 5.0
+        
+        let textSize = self.textNode.measure(CGSize(width: size.width - 32.0, height: size.height))
+        transition.updateFrame(node: self.textNode, frame: CGRect(origin: CGPoint(x: floorToScreenPixels((size.width - textSize.width) / 2.0), y: origin.y), size: textSize))
+        
+        let actionButtonHeight: CGFloat = 44.0
+        var minActionsWidth: CGFloat = 0.0
+        let maxActionWidth: CGFloat = floor(size.width / CGFloat(self.actionNodes.count))
+        let actionTitleInsets: CGFloat = 8.0
+        
+        var effectiveActionLayout = TextAlertContentActionLayout.horizontal
+        for actionNode in self.actionNodes {
+            let actionTitleSize = actionNode.titleNode.updateLayout(CGSize(width: maxActionWidth, height: actionButtonHeight))
+            if case .horizontal = effectiveActionLayout, actionTitleSize.height > actionButtonHeight * 0.6667 {
+                effectiveActionLayout = .vertical
+            }
+            switch effectiveActionLayout {
+                case .horizontal:
+                    minActionsWidth += actionTitleSize.width + actionTitleInsets
+                case .vertical:
+                    minActionsWidth = max(minActionsWidth, actionTitleSize.width + actionTitleInsets)
+            }
+        }
+        
+        let insets = UIEdgeInsets(top: 18.0, left: 18.0, bottom: 18.0, right: 18.0)
+        
+        var contentWidth = max(titleSize.width, minActionsWidth)
+        contentWidth = max(contentWidth, 234.0)
+        
+        var actionsHeight: CGFloat = 0.0
+        switch effectiveActionLayout {
+            case .horizontal:
+                actionsHeight = actionButtonHeight
+            case .vertical:
+                actionsHeight = actionButtonHeight * CGFloat(self.actionNodes.count)
+        }
+        
+        let resultWidth = contentWidth + insets.left + insets.right
+        let resultSize = CGSize(width: resultWidth, height: titleSize.height + starHeight + textSize.height + actionsHeight + 7.0 + insets.top + insets.bottom)
+        
+        transition.updateFrame(node: self.actionNodesSeparator, frame: CGRect(origin: CGPoint(x: 0.0, y: resultSize.height - actionsHeight - UIScreenPixel), size: CGSize(width: resultSize.width, height: UIScreenPixel)))
+        
+        var actionOffset: CGFloat = 0.0
+        let actionWidth: CGFloat = floor(resultSize.width / CGFloat(self.actionNodes.count))
+        var separatorIndex = -1
+        var nodeIndex = 0
+        for actionNode in self.actionNodes {
+            if separatorIndex >= 0 {
+                let separatorNode = self.actionVerticalSeparators[separatorIndex]
+                switch effectiveActionLayout {
+                    case .horizontal:
+                        transition.updateFrame(node: separatorNode, frame: CGRect(origin: CGPoint(x: actionOffset - UIScreenPixel, y: resultSize.height - actionsHeight), size: CGSize(width: UIScreenPixel, height: actionsHeight - UIScreenPixel)))
+                    case .vertical:
+                        transition.updateFrame(node: separatorNode, frame: CGRect(origin: CGPoint(x: 0.0, y: resultSize.height - actionsHeight + actionOffset - UIScreenPixel), size: CGSize(width: resultSize.width, height: UIScreenPixel)))
+                }
+            }
+            separatorIndex += 1
+            
+            let currentActionWidth: CGFloat
+            switch effectiveActionLayout {
+                case .horizontal:
+                    if nodeIndex == self.actionNodes.count - 1 {
+                        currentActionWidth = resultSize.width - actionOffset
+                    } else {
+                        currentActionWidth = actionWidth
+                    }
+                case .vertical:
+                    currentActionWidth = resultSize.width
+            }
+            
+            let actionNodeFrame: CGRect
+            switch effectiveActionLayout {
+                case .horizontal:
+                    actionNodeFrame = CGRect(origin: CGPoint(x: actionOffset, y: resultSize.height - actionsHeight), size: CGSize(width: currentActionWidth, height: actionButtonHeight))
+                    actionOffset += currentActionWidth
+                case .vertical:
+                    actionNodeFrame = CGRect(origin: CGPoint(x: 0.0, y: resultSize.height - actionsHeight + actionOffset), size: CGSize(width: currentActionWidth, height: actionButtonHeight))
+                    actionOffset += actionButtonHeight
+            }
+            
+            transition.updateFrame(node: actionNode, frame: actionNodeFrame)
+            
+            nodeIndex += 1
+        }
+        
+        return resultSize
+    }
+}
+
+func premiumAlertController(context: AccountContext, parentController: ViewController, title: String? = nil, text: String) -> AlertController {
+    let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+    let strings = presentationData.strings
+    
+    var dismissImpl: ((Bool) -> Void)?
+    var proceedImpl: (() -> Void)?
+    var contentNode: PremiumAlertContentNode?
+    let actions: [TextAlertAction] = [TextAlertAction(type: .genericAction, title: presentationData.strings.Common_Cancel, action: {
+        dismissImpl?(true)
+    }), TextAlertAction(type: .defaultAction, title: presentationData.strings.PremiumNeeded_Subscribe, action: {
+        proceedImpl?()
+        
+        dismissImpl?(true)
+    })]
+        
+    contentNode = PremiumAlertContentNode(
+        theme: AlertControllerTheme(presentationData: presentationData),
+        presentationTheme: presentationData.theme,
+        strings: strings,
+        title: title,
+        text: text,
+        actions: actions
+    )
+    
+    let controller = AlertController(theme: AlertControllerTheme(presentationData: presentationData), contentNode: contentNode!)
+    dismissImpl = { [weak controller] animated in
+        if animated {
+            controller?.dismissAnimated()
+        } else {
+            controller?.dismiss()
+        }
+    }
+    
+    proceedImpl = { [weak parentController] in
+        let controller = context.sharedContext.makePremiumIntroController(context: context, source: .nameColor, forceDark: false, dismissed: nil)
+        parentController?.push(controller)
+    }
+    
+    return controller
+}