Merge commit '7621e2f8dec938cf48181c8b10afc9b01f444e68' into beta

submodules/JoinLinkPreviewUI/BUILD

@@ -0,0 +1,32 @@
+load("@build_bazel_rules_swift//swift:swift.bzl", "swift_library")
+
+swift_library(
+    name = "JoinLinkPreviewUI",
+    module_name = "JoinLinkPreviewUI",
+    srcs = glob([
+		"Sources/**/*.swift",
+    ]),
+    copts = [
+        "-warnings-as-errors",
+    ],
+    deps = [
+        "//submodules/SSignalKit/SwiftSignalKit:SwiftSignalKit",
+        "//submodules/AsyncDisplayKit:AsyncDisplayKit",
+        "//submodules/Display:Display",
+        "//submodules/TelegramCore:TelegramCore",
+        "//submodules/TelegramPresentationData:TelegramPresentationData",
+        "//submodules/AccountContext:AccountContext",
+        "//submodules/AlertUI:AlertUI",
+        "//submodules/PresentationDataUtils:PresentationDataUtils",
+        "//submodules/ShareController:ShareController",
+        "//submodules/SelectablePeerNode:SelectablePeerNode",
+        "//submodules/UndoUI:UndoUI",
+        "//submodules/SolidRoundedButtonNode:SolidRoundedButtonNode",
+        "//submodules/ComponentFlow",
+        "//submodules/TelegramUI/Components/EmojiStatusComponent",
+        "//submodules/TelegramUI/Components/PeerManagement/OldChannelsController",
+    ],
+    visibility = [
+        "//visibility:public",
+    ],
+)

submodules/JoinLinkPreviewUI/Sources/JoinLinkPreviewController.swift

@@ -0,0 +1,220 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import TelegramCore
+import SwiftSignalKit
+import TelegramPresentationData
+import AccountContext
+import AlertUI
+import PresentationDataUtils
+import UndoUI
+import OldChannelsController
+
+public final class LegacyJoinLinkPreviewController: ViewController {
+    private var controllerNode: JoinLinkPreviewControllerNode {
+        return self.displayNode as! JoinLinkPreviewControllerNode
+    }
+    
+    private var animatedIn = false
+    
+    private let context: AccountContext
+    private let link: String
+    private var isRequest = false
+    private var isGroup = false
+    private let navigateToPeer: (EnginePeer, ChatPeekTimeout?) -> Void
+    private let parentNavigationController: NavigationController?
+    private var resolvedState: ExternalJoiningChatState?
+    private var presentationData: PresentationData
+    
+    private let disposable = MetaDisposable()
+    
+    public init(context: AccountContext, link: String, navigateToPeer: @escaping (EnginePeer, ChatPeekTimeout?) -> Void, parentNavigationController: NavigationController?, resolvedState: ExternalJoiningChatState? = nil) {
+        self.context = context
+        self.link = link
+        self.navigateToPeer = navigateToPeer
+        self.parentNavigationController = parentNavigationController
+        self.resolvedState = resolvedState
+        
+        self.presentationData = context.sharedContext.currentPresentationData.with { $0 }
+        
+        super.init(navigationBarPresentationData: nil)
+        
+        self.statusBar.statusBarStyle = .Ignore
+    }
+    
+    required public init(coder aDecoder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+    
+    deinit {
+        self.disposable.dispose()
+    }
+    
+    override public func loadDisplayNode() {
+        self.displayNode = JoinLinkPreviewControllerNode(context: self.context, requestLayout: { [weak self] transition in
+            self?.requestLayout(transition: transition)
+        })
+        self.controllerNode.dismiss = { [weak self] in
+            self?.presentingViewController?.dismiss(animated: false, completion: nil)
+        }
+        self.controllerNode.cancel = { [weak self] in
+            self?.dismiss()
+        }
+        self.controllerNode.join = { [weak self] in
+            self?.join()
+        }
+        self.displayNodeDidLoad()
+        
+        let signal: Signal<ExternalJoiningChatState, JoinLinkInfoError>
+        if let resolvedState = self.resolvedState {
+            signal = .single(resolvedState)
+        } else {
+            signal = self.context.engine.peers.joinLinkInformation(self.link)
+        }
+        
+        self.disposable.set((signal
+        |> deliverOnMainQueue).start(next: { [weak self] result in
+            if let strongSelf = self {
+                strongSelf.resolvedState = result
+                switch result {
+                    case let .invite(invite):
+                        if invite.flags.requestNeeded {
+                            strongSelf.isRequest = true
+                            strongSelf.isGroup = !invite.flags.isBroadcast
+                            strongSelf.controllerNode.setRequestPeer(image: invite.photoRepresentation, title: invite.title, about: invite.about, memberCount: invite.participantsCount, isGroup: !invite.flags.isBroadcast, isVerified: invite.flags.isVerified, isFake: invite.flags.isFake, isScam: invite.flags.isScam)
+                        } else {
+                            let data = JoinLinkPreviewData(isGroup: !invite.flags.isBroadcast, isJoined: false)
+                            strongSelf.controllerNode.setInvitePeer(image: invite.photoRepresentation, title: invite.title, about: invite.about, memberCount: invite.participantsCount, members: invite.participants?.map({ $0 }) ?? [], data: data)
+                        }
+                    case let .alreadyJoined(peer):
+                        strongSelf.navigateToPeer(peer, nil)
+                        strongSelf.dismiss()
+                    case let .peek(peer, deadline):
+                        strongSelf.navigateToPeer(peer, ChatPeekTimeout(deadline: deadline, linkData: strongSelf.link))
+                        strongSelf.dismiss()
+                    case .invalidHash:
+                        let presentationData = strongSelf.context.sharedContext.currentPresentationData.with { $0 }
+                        Queue.mainQueue().after(0.2) {
+                            strongSelf.present(UndoOverlayController(presentationData: presentationData, content: .linkRevoked(text: presentationData.strings.InviteLinks_InviteLinkExpired), elevatedLayout: true, animateInAsReplacement: true, action: { _ in return false }), in: .window(.root))
+                            strongSelf.dismiss()
+                        }
+                }
+            }
+        }, error: { [weak self] error in
+            if let strongSelf = self {
+                switch error {
+                    case .flood:
+                        strongSelf.present(textAlertController(context: strongSelf.context, title: nil, text: strongSelf.presentationData.strings.TwoStepAuth_FloodError, actions: [TextAlertAction(type: .defaultAction, title: strongSelf.presentationData.strings.Common_OK, action: {})]), in: .window(.root))
+                    default:
+                        break
+                }
+                strongSelf.dismiss()
+            }
+        }))
+        self.ready.set(self.controllerNode.ready.get())
+    }
+    
+    override public func loadView() {
+        super.loadView()
+    }
+    
+    override public func viewDidAppear(_ animated: Bool) {
+        super.viewDidAppear(animated)
+        
+        if !self.animatedIn {
+            self.animatedIn = true
+            self.controllerNode.animateIn()
+        }
+    }
+    
+    override public func dismiss(completion: (() -> Void)? = nil) {
+        self.controllerNode.animateOut(completion: completion)
+    }
+    
+    override public func containerLayoutUpdated(_ layout: ContainerViewLayout, transition: ContainedViewLayoutTransition) {
+        super.containerLayoutUpdated(layout, transition: transition)
+        
+        self.controllerNode.containerLayoutUpdated(layout, navigationBarHeight: self.navigationLayout(layout: layout).navigationFrame.maxY, transition: transition)
+    }
+    
+    private func join() {
+        self.disposable.set((self.context.engine.peers.joinChatInteractively(with: self.link) |> deliverOnMainQueue).start(next: { [weak self] peer in
+            if let strongSelf = self {
+                if strongSelf.isRequest {
+                    strongSelf.present(UndoOverlayController(presentationData: strongSelf.presentationData, content: .inviteRequestSent(title: strongSelf.presentationData.strings.MemberRequests_RequestToJoinSent, text: strongSelf.isGroup ? strongSelf.presentationData.strings.MemberRequests_RequestToJoinSentDescriptionGroup : strongSelf.presentationData.strings.MemberRequests_RequestToJoinSentDescriptionChannel ), elevatedLayout: true, animateInAsReplacement: false, action: { _ in return false }), in: .window(.root))
+                } else {
+                    if let peer = peer {
+                        strongSelf.navigateToPeer(peer, nil)
+                    }
+                }
+                strongSelf.dismiss()
+            }
+        }, error: { [weak self] error in
+            if let strongSelf = self {
+                switch error {
+                    case .tooMuchJoined:
+                        if let parentNavigationController = strongSelf.parentNavigationController {
+                            let context = strongSelf.context
+                            let link = strongSelf.link
+                            let navigateToPeer = strongSelf.navigateToPeer
+                            let resolvedState = strongSelf.resolvedState
+                            parentNavigationController.pushViewController(oldChannelsController(context: strongSelf.context, intent: .join, completed: { [weak parentNavigationController] value in
+                                if value {
+                                    (parentNavigationController?.viewControllers.last as? ViewController)?.present(JoinLinkPreviewController(context: context, link: link, navigateToPeer: navigateToPeer, parentNavigationController: parentNavigationController, resolvedState: resolvedState), in: .window(.root))
+                                }
+                            }))
+                        } else {
+                            strongSelf.present(textAlertController(context: strongSelf.context, title: nil, text: strongSelf.presentationData.strings.Join_ChannelsTooMuch, actions: [TextAlertAction(type: .defaultAction, title: strongSelf.presentationData.strings.Common_OK, action: {})]), in: .window(.root))
+                        }
+                    case .tooMuchUsers:
+                        strongSelf.present(textAlertController(context: strongSelf.context, title: nil, text: strongSelf.presentationData.strings.Conversation_UsersTooMuchError, actions: [TextAlertAction(type: .defaultAction, title: strongSelf.presentationData.strings.Common_OK, action: {})]), in: .window(.root))
+                    case .requestSent:
+                        if strongSelf.isRequest {
+                            strongSelf.present(UndoOverlayController(presentationData: strongSelf.presentationData, content: .inviteRequestSent(title: strongSelf.presentationData.strings.MemberRequests_RequestToJoinSent, text: strongSelf.isGroup ? strongSelf.presentationData.strings.MemberRequests_RequestToJoinSentDescriptionGroup : strongSelf.presentationData.strings.MemberRequests_RequestToJoinSentDescriptionChannel ), elevatedLayout: true, animateInAsReplacement: false, action: { _ in return false }), in: .window(.root))
+                        }
+                    case .flood:
+                        strongSelf.present(textAlertController(context: strongSelf.context, title: nil, text: strongSelf.presentationData.strings.TwoStepAuth_FloodError, actions: [TextAlertAction(type: .defaultAction, title: strongSelf.presentationData.strings.Common_OK, action: {})]), in: .window(.root))
+                    case .generic:
+                        break
+                }
+                strongSelf.dismiss()
+            }
+        }))
+    }
+}
+
+public func JoinLinkPreviewController(
+    context: AccountContext,
+    link: String,
+    navigateToPeer: @escaping (EnginePeer, ChatPeekTimeout?) -> Void,
+    parentNavigationController: NavigationController?,
+    resolvedState: ExternalJoiningChatState? = nil
+) -> ViewController {
+    if let data = context.currentAppConfiguration.with({ $0 }).data, data["ios_killswitch_legacy_join_link"] != nil {
+        return LegacyJoinLinkPreviewController(context: context, link: link, navigateToPeer: navigateToPeer, parentNavigationController: parentNavigationController, resolvedState: resolvedState)
+    } else if case let .invite(invite) = resolvedState, !invite.flags.requestNeeded, !invite.flags.isBroadcast, !invite.flags.canRefulfillSubscription { 
+        var verificationStatus: JoinSubjectScreenMode.Group.VerificationStatus?
+        if invite.flags.isFake {
+            verificationStatus = .fake
+        } else if invite.flags.isScam {
+            verificationStatus = .scam
+        } else if invite.flags.isVerified {
+            verificationStatus = .verified
+        }
+        return context.sharedContext.makeJoinSubjectScreen(context: context, mode: .group(JoinSubjectScreenMode.Group(
+            link: link,
+            isGroup: !invite.flags.isChannel,
+            isPublic: invite.flags.isPublic,
+            isRequest: invite.flags.requestNeeded,
+            verificationStatus: verificationStatus,
+            image: invite.photoRepresentation,
+            title: invite.title,
+            about: invite.about,
+            memberCount: invite.participantsCount,
+            members: invite.participants ?? []
+        )))
+    } else {
+        return LegacyJoinLinkPreviewController(context: context, link: link, navigateToPeer: navigateToPeer, parentNavigationController: parentNavigationController, resolvedState: resolvedState)
+    }
+}

submodules/JoinLinkPreviewUI/Sources/JoinLinkPreviewControllerNode.swift

@@ -0,0 +1,410 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import TelegramCore
+import TelegramPresentationData
+import AccountContext
+import ShareController
+
+private func closeButtonImage(theme: PresentationTheme) -> UIImage? {
+    return generateImage(CGSize(width: 30.0, height: 30.0), contextGenerator: { size, context in
+        context.clear(CGRect(origin: CGPoint(), size: size))
+        
+        context.setFillColor(UIColor(rgb: 0x808084, alpha: 0.1).cgColor)
+        context.fillEllipse(in: CGRect(origin: CGPoint(), size: size))
+        
+        context.setLineWidth(2.0)
+        context.setLineCap(.round)
+        context.setStrokeColor(theme.actionSheet.inputClearButtonColor.cgColor)
+        
+        context.move(to: CGPoint(x: 10.0, y: 10.0))
+        context.addLine(to: CGPoint(x: 20.0, y: 20.0))
+        context.strokePath()
+        
+        context.move(to: CGPoint(x: 20.0, y: 10.0))
+        context.addLine(to: CGPoint(x: 10.0, y: 20.0))
+        context.strokePath()
+    })
+}
+
+struct JoinLinkPreviewData {
+    let isGroup: Bool
+    let isJoined: Bool
+}
+
+final class JoinLinkPreviewControllerNode: ViewControllerTracingNode, ASScrollViewDelegate {
+    private let context: AccountContext
+    private var presentationData: PresentationData
+    
+    private let requestLayout: (ContainedViewLayoutTransition) -> Void
+    
+    private var containerLayout: (ContainerViewLayout, CGFloat, CGFloat)?
+    
+    private let dimNode: ASDisplayNode
+    
+    private let wrappingScrollNode: ASScrollNode
+    
+    private let contentContainerNode: ASDisplayNode
+    private let effectNode: ASDisplayNode
+    private let backgroundNode: ASDisplayNode
+    private let contentBackgroundNode: ASDisplayNode
+    
+    private var contentNode: (ASDisplayNode & ShareContentContainerNode)?
+    private var previousContentNode: (ASDisplayNode & ShareContentContainerNode)?
+    private var animateContentNodeOffsetFromBackgroundOffset: CGFloat?
+    
+    private let cancelButton: HighlightableButtonNode
+    
+    var dismiss: (() -> Void)?
+    var cancel: (() -> Void)?
+    var join: (() -> Void)?
+    
+    let ready = Promise<Bool>()
+    private var didSetReady = false
+    
+    private var scheduledLayoutTransitionRequestId: Int = 0
+    private var scheduledLayoutTransitionRequest: (Int, ContainedViewLayoutTransition)?
+    
+    private let disposable = MetaDisposable()
+    
+    init(context: AccountContext, requestLayout: @escaping (ContainedViewLayoutTransition) -> Void) {
+        self.context = context
+        
+        let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+        self.presentationData = presentationData
+        
+        self.requestLayout = requestLayout
+        
+        self.wrappingScrollNode = ASScrollNode()
+        self.wrappingScrollNode.view.alwaysBounceVertical = true
+        self.wrappingScrollNode.view.delaysContentTouches = false
+        self.wrappingScrollNode.view.canCancelContentTouches = true
+        
+        self.dimNode = ASDisplayNode()
+        self.dimNode.backgroundColor = UIColor(white: 0.0, alpha: 0.5)
+        
+        self.contentContainerNode = ASDisplayNode()
+        self.contentContainerNode.isOpaque = false
+        
+        self.backgroundNode = ASDisplayNode()
+        self.backgroundNode.clipsToBounds = true
+        self.backgroundNode.cornerRadius = 16.0
+        
+        self.effectNode = ASDisplayNode(viewBlock: {
+            return UIVisualEffectView(effect: UIBlurEffect(style: presentationData.theme.actionSheet.backgroundType == .light ? .light : .dark))
+        })
+        
+        self.contentBackgroundNode = ASDisplayNode()
+        self.contentBackgroundNode.backgroundColor = self.presentationData.theme.actionSheet.itemBackgroundColor
+                
+        self.cancelButton = HighlightableButtonNode()
+        self.cancelButton.setImage(closeButtonImage(theme: self.presentationData.theme), for: .normal)
+        
+        super.init()
+        
+        self.backgroundColor = nil
+        self.isOpaque = false
+        
+        self.dimNode.view.addGestureRecognizer(UITapGestureRecognizer(target: self, action: #selector(self.dimTapGesture(_:))))
+        self.addSubnode(self.dimNode)
+        
+        self.wrappingScrollNode.view.delegate = self.wrappedScrollViewDelegate
+        self.addSubnode(self.wrappingScrollNode)
+                
+        self.cancelButton.addTarget(self, action: #selector(self.cancelButtonPressed), forControlEvents: .touchUpInside)
+                
+        self.backgroundNode.addSubnode(self.effectNode)
+        self.backgroundNode.addSubnode(self.contentBackgroundNode)
+        
+        self.wrappingScrollNode.addSubnode(self.backgroundNode)
+        self.wrappingScrollNode.addSubnode(self.contentContainerNode)
+        self.wrappingScrollNode.addSubnode(self.cancelButton)
+        
+        self.transitionToContentNode(JoinLinkPreviewLoadingContainerNode(theme: self.presentationData.theme))
+                
+        self.ready.set(.single(true))
+        self.didSetReady = true
+    }
+    
+    deinit {
+        self.disposable.dispose()
+    }
+    
+    override func didLoad() {
+        super.didLoad()
+        
+        if #available(iOSApplicationExtension 11.0, iOS 11.0, *) {
+            self.wrappingScrollNode.view.contentInsetAdjustmentBehavior = .never
+        }
+    }
+    
+    func transitionToContentNode(_ contentNode: (ASDisplayNode & ShareContentContainerNode)?, fastOut: Bool = false) {
+        if self.contentNode !== contentNode {
+            let transition: ContainedViewLayoutTransition
+            
+            let previous = self.contentNode
+            if let previous = previous {
+                previous.setContentOffsetUpdated(nil)
+                transition = .animated(duration: 0.4, curve: .spring)
+                
+                self.previousContentNode = previous
+                previous.alpha = 0.0
+                previous.layer.animateAlpha(from: 1.0, to: 0.0, duration: fastOut ? 0.1 : 0.2, removeOnCompletion: true, completion: { [weak self, weak previous] _ in
+                    if let strongSelf = self, let previous = previous {
+                        if strongSelf.previousContentNode === previous {
+                            strongSelf.previousContentNode = nil
+                        }
+                        previous.removeFromSupernode()
+                    }
+                })
+            } else {
+                transition = .immediate
+            }
+            self.contentNode = contentNode
+            
+            if let (layout, navigationBarHeight, bottomGridInset) = self.containerLayout {
+                if let contentNode = contentNode, let previous = previous {
+                    contentNode.frame = previous.frame
+                    contentNode.updateLayout(size: previous.bounds.size, isLandscape: layout.size.width > layout.size.height, bottomInset: bottomGridInset, transition: .immediate)
+                    
+                    contentNode.setContentOffsetUpdated({ [weak self] contentOffset, transition in
+                        self?.contentNodeOffsetUpdated(contentOffset, transition: transition)
+                    })
+                    self.contentContainerNode.insertSubnode(contentNode, at: 0)
+                    
+                    contentNode.alpha = 1.0
+                    let animation = contentNode.layer.makeAnimation(from: 0.0 as NSNumber, to: 1.0 as NSNumber, keyPath: "opacity", timingFunction: CAMediaTimingFunctionName.easeInEaseOut.rawValue, duration: 0.25)
+                    animation.fillMode = .both
+                    if !fastOut {
+                        animation.beginTime = contentNode.layer.convertTime(CACurrentMediaTime(), from: nil) + 0.1
+                    }
+                    contentNode.layer.add(animation, forKey: "opacity")
+                    
+                    self.animateContentNodeOffsetFromBackgroundOffset = self.backgroundNode.frame.minY
+                    self.scheduleInteractiveTransition(transition)
+                    
+                    contentNode.activate()
+                    previous.deactivate()
+                } else {
+                    if let contentNode = self.contentNode {
+                        contentNode.setContentOffsetUpdated({ [weak self] contentOffset, transition in
+                            self?.contentNodeOffsetUpdated(contentOffset, transition: transition)
+                        })
+                        self.contentContainerNode.insertSubnode(contentNode, at: 0)
+                    }
+                    
+                    self.containerLayoutUpdated(layout, navigationBarHeight: navigationBarHeight, transition: transition)
+                }
+            } else if let contentNode = contentNode {
+                contentNode.setContentOffsetUpdated({ [weak self] contentOffset, transition in
+                    self?.contentNodeOffsetUpdated(contentOffset, transition: transition)
+                })
+                self.contentContainerNode.insertSubnode(contentNode, at: 0)
+            }
+        }
+    }
+    
+    func containerLayoutUpdated(_ layout: ContainerViewLayout, navigationBarHeight: CGFloat, transition: ContainedViewLayoutTransition) {
+        var insets = layout.insets(options: [.statusBar, .input])
+        let cleanInsets = layout.insets(options: [.statusBar])
+        insets.top = max(10.0, insets.top)
+        
+        var bottomInset: CGFloat = 10.0 + cleanInsets.bottom
+        if insets.bottom > 0.0 {
+            bottomInset -= 12.0
+        }
+        
+        let maximumContentHeight = layout.size.height - insets.top - max(bottomInset, insets.bottom)
+        
+        let width = horizontalContainerFillingSizeForLayout(layout: layout, sideInset: 0.0)
+        let sideInset = floor((layout.size.width - width) / 2.0)
+        
+        let contentContainerFrame = CGRect(origin: CGPoint(x: sideInset, y: insets.top), size: CGSize(width: width, height: maximumContentHeight))
+        let contentFrame = contentContainerFrame
+                
+        self.containerLayout = (layout, navigationBarHeight, 0.0)
+        self.scheduledLayoutTransitionRequest = nil
+        
+        transition.updateFrame(node: self.wrappingScrollNode, frame: CGRect(origin: CGPoint(), size: layout.size))
+        transition.updateFrame(node: self.dimNode, frame: CGRect(origin: CGPoint(), size: layout.size))
+                
+        transition.updateFrame(node: self.contentContainerNode, frame: contentContainerFrame)
+        
+        let gridSize = CGSize(width: contentFrame.size.width, height: max(32.0, contentFrame.size.height))
+        
+        if let contentNode = self.contentNode {
+            transition.updateFrame(node: contentNode, frame: CGRect(origin: CGPoint(x: floor((contentContainerFrame.size.width - contentFrame.size.width) / 2.0), y: 0.0), size: gridSize))
+            contentNode.updateLayout(size: gridSize, isLandscape: layout.size.width > layout.size.height && layout.metrics.widthClass == .compact, bottomInset: 0.0, transition: transition)
+        }
+    }
+    
+    private func contentNodeOffsetUpdated(_ contentOffset: CGFloat, transition: ContainedViewLayoutTransition) {
+        if let (layout, _, _) = self.containerLayout {
+            var insets = layout.insets(options: [.statusBar, .input])
+            insets.top = max(10.0, insets.top)
+            let cleanInsets = layout.insets(options: [.statusBar])
+            
+            var bottomInset: CGFloat = 10.0 + cleanInsets.bottom
+            if insets.bottom > 0 {
+                bottomInset -= 12.0
+            }
+            
+            let width = horizontalContainerFillingSizeForLayout(layout: layout, sideInset: 0.0)
+            let sideInset = floor((layout.size.width - width) / 2.0)
+            
+            let maximumContentHeight = layout.size.height - insets.top - max(bottomInset, insets.bottom)
+            let contentFrame = CGRect(origin: CGPoint(x: sideInset, y: insets.top), size: CGSize(width: width, height: maximumContentHeight))
+            
+            var backgroundFrame = CGRect(origin: CGPoint(x: contentFrame.minX, y: contentFrame.minY - contentOffset), size: contentFrame.size)
+            if backgroundFrame.minY < contentFrame.minY {
+                backgroundFrame.origin.y = contentFrame.minY
+            }
+            if backgroundFrame.maxY > contentFrame.maxY {
+                backgroundFrame.size.height += contentFrame.maxY - backgroundFrame.maxY
+            }
+            backgroundFrame.size.height += 2000.0
+
+            transition.updateFrame(node: self.backgroundNode, frame: backgroundFrame)
+            transition.updateFrame(node: self.effectNode, frame: CGRect(origin: CGPoint(), size: backgroundFrame.size))
+            transition.updateFrame(node: self.contentBackgroundNode, frame: CGRect(origin: CGPoint(), size: backgroundFrame.size))
+            
+            let cancelSize = CGSize(width: 44.0, height: 44.0)
+            let cancelFrame = CGRect(origin: CGPoint(x: backgroundFrame.maxX - cancelSize.width - 3.0, y: backgroundFrame.minY + 6.0), size: cancelSize)
+            transition.updateFrame(node: self.cancelButton, frame: cancelFrame)
+            
+            if let animateContentNodeOffsetFromBackgroundOffset = self.animateContentNodeOffsetFromBackgroundOffset {
+                self.animateContentNodeOffsetFromBackgroundOffset = nil
+                let offset = backgroundFrame.minY - animateContentNodeOffsetFromBackgroundOffset
+                if let contentNode = self.contentNode {
+                    transition.animatePositionAdditive(node: contentNode, offset: CGPoint(x: 0.0, y: -offset))
+                }
+                if let previousContentNode = self.previousContentNode {
+                    transition.updatePosition(node: previousContentNode, position: previousContentNode.position.offsetBy(dx: 0.0, dy: offset))
+                }
+            }
+        }
+    }
+    
+    @objc func dimTapGesture(_ recognizer: UITapGestureRecognizer) {
+        if case .ended = recognizer.state {
+            self.cancelButtonPressed()
+        }
+    }
+    
+    @objc func cancelButtonPressed() {
+        self.cancel?()
+    }
+    
+    func animateIn() {
+        if self.contentNode != nil {
+            self.dimNode.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.4)
+            
+            let offset = self.bounds.size.height - self.contentBackgroundNode.frame.minY
+            
+            let dimPosition = self.dimNode.layer.position
+            self.dimNode.layer.animatePosition(from: CGPoint(x: dimPosition.x, y: dimPosition.y - offset), to: dimPosition, duration: 0.3, timingFunction: kCAMediaTimingFunctionSpring)
+            self.layer.animateBoundsOriginYAdditive(from: -offset, to: 0.0, duration: 0.3, timingFunction: kCAMediaTimingFunctionSpring)
+        }
+    }
+    
+    private var animatingOut = false
+    func animateOut(completion: (() -> Void)? = nil) {
+        guard !self.animatingOut else {
+            return
+        }
+        self.animatingOut = true
+        
+        if self.contentNode != nil {
+            var dimCompleted = false
+            var offsetCompleted = false
+            
+            let internalCompletion: () -> Void = { [weak self] in
+                if let strongSelf = self, dimCompleted && offsetCompleted {
+                    strongSelf.dismiss?()
+                    strongSelf.animatingOut = true
+                }
+                completion?()
+            }
+            
+            self.dimNode.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.3, removeOnCompletion: false, completion: { _ in
+                dimCompleted = true
+                internalCompletion()
+            })
+            
+            let offset = self.bounds.size.height - self.contentBackgroundNode.frame.minY
+            let dimPosition = self.dimNode.layer.position
+            self.dimNode.layer.animatePosition(from: dimPosition, to: CGPoint(x: dimPosition.x, y: dimPosition.y - offset), duration: 0.3, timingFunction: CAMediaTimingFunctionName.easeInEaseOut.rawValue, removeOnCompletion: false)
+            self.layer.animateBoundsOriginYAdditive(from: 0.0, to: -offset, duration: 0.3, timingFunction: CAMediaTimingFunctionName.easeInEaseOut.rawValue, removeOnCompletion: false, completion: { _ in
+                offsetCompleted = true
+                internalCompletion()
+            })
+        } else {
+            self.dismiss?()
+            completion?()
+        }
+    }
+    
+    override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
+        if self.bounds.contains(point) {
+            if !self.contentBackgroundNode.bounds.contains(self.convert(point, to: self.contentBackgroundNode)) && !self.cancelButton.bounds.contains(self.convert(point, to: self.cancelButton)) {
+                return self.dimNode.view
+            }
+        }
+        return super.hitTest(point, with: event)
+    }
+    
+    func scrollViewDidEndDragging(_ scrollView: UIScrollView, willDecelerate decelerate: Bool) {
+        let contentOffset = scrollView.contentOffset
+        let additionalTopHeight = max(0.0, -contentOffset.y)
+        
+        if additionalTopHeight >= 30.0 {
+            self.cancelButtonPressed()
+        }
+    }
+    
+    private func scheduleInteractiveTransition(_ transition: ContainedViewLayoutTransition) {
+        if let scheduledLayoutTransitionRequest = self.scheduledLayoutTransitionRequest {
+            switch scheduledLayoutTransitionRequest.1 {
+            case .immediate:
+                self.scheduleLayoutTransitionRequest(transition)
+            default:
+                break
+            }
+        } else {
+            self.scheduleLayoutTransitionRequest(transition)
+        }
+    }
+    
+    private func scheduleLayoutTransitionRequest(_ transition: ContainedViewLayoutTransition) {
+        let requestId = self.scheduledLayoutTransitionRequestId
+        self.scheduledLayoutTransitionRequestId += 1
+        self.scheduledLayoutTransitionRequest = (requestId, transition)
+        (self.view as? UITracingLayerView)?.schedule(layout: { [weak self] in
+            if let strongSelf = self {
+                if let (currentRequestId, currentRequestTransition) = strongSelf.scheduledLayoutTransitionRequest, currentRequestId == requestId {
+                    strongSelf.scheduledLayoutTransitionRequest = nil
+                    strongSelf.requestLayout(currentRequestTransition)
+                }
+            }
+        })
+        self.setNeedsLayout()
+    }
+    
+    func setInvitePeer(image: TelegramMediaImageRepresentation?, title: String, about: String?, memberCount: Int32, members: [EnginePeer], data: JoinLinkPreviewData) {
+        let contentNode = JoinLinkPreviewPeerContentNode(context: self.context, theme: self.presentationData.theme, strings: self.presentationData.strings, content: .invite(isGroup: data.isGroup, image: image, title: title, about: about, memberCount: memberCount, members: members))
+        contentNode.join = { [weak self] in
+            self?.join?()
+        }
+        self.transitionToContentNode(contentNode)
+    }
+    
+    func setRequestPeer(image: TelegramMediaImageRepresentation?, title: String, about: String?, memberCount: Int32, isGroup: Bool, isVerified: Bool, isFake: Bool, isScam: Bool) {
+        let contentNode = JoinLinkPreviewPeerContentNode(context: self.context, theme: self.presentationData.theme, strings: self.presentationData.strings, content: .request(isGroup: isGroup, image: image, title: title, about: about, memberCount: memberCount, isVerified: isVerified, isFake: isFake, isScam: isScam))
+        contentNode.join = { [weak self] in
+            self?.join?()
+        }
+        self.transitionToContentNode(contentNode)
+    }
+}

submodules/JoinLinkPreviewUI/Sources/JoinLinkPreviewPeerContentNode.swift

@@ -0,0 +1,448 @@
+import Foundation
+import UIKit
+import AsyncDisplayKit
+import Display
+import TelegramCore
+import TelegramPresentationData
+import AvatarNode
+import AccountContext
+import SelectablePeerNode
+import ShareController
+import SolidRoundedButtonNode
+import ActivityIndicator
+import ComponentFlow
+import EmojiStatusComponent
+
+private let avatarFont = avatarPlaceholderFont(size: 42.0)
+
+private final class MoreNode: ASDisplayNode {
+    private let avatarNode = AvatarNode(font: Font.regular(24.0))
+    
+    init(count: Int) {
+        super.init()
+        
+        self.addSubnode(self.avatarNode)
+        self.avatarNode.setCustomLetters(["+\(count)"])
+    }
+    
+    func updateLayout(size: CGSize) {
+        self.avatarNode.frame = CGRect(origin: CGPoint(x: floor((size.width - 60.0) / 2.0), y: 4.0), size: CGSize(width: 60.0, height: 60.0))
+    }
+}
+
+final class JoinLinkPreviewPeerContentNode: ASDisplayNode, ShareContentContainerNode {
+    enum Content {
+        case invite(isGroup: Bool, image: TelegramMediaImageRepresentation?, title: String, about: String?, memberCount: Int32, members: [EnginePeer])
+        case request(isGroup: Bool, image: TelegramMediaImageRepresentation?, title: String, about: String?, memberCount: Int32, isVerified: Bool, isFake: Bool, isScam: Bool)
+        
+        var isGroup: Bool {
+            switch self {
+                case let .invite(isGroup, _, _, _, _, _), let .request(isGroup, _, _, _, _, _, _, _):
+                    return isGroup
+            }
+        }
+        
+        var image: TelegramMediaImageRepresentation? {
+            switch self {
+                case let .invite(_, image, _, _, _, _), let .request(_, image, _, _, _, _, _, _):
+                    return image
+            }
+        }
+        
+        var title: String {
+            switch self {
+                case let .invite(_, _, title, _, _, _), let .request(_, _, title, _, _, _, _, _):
+                    return title
+            }
+        }
+        
+        var memberCount: Int32 {
+            switch self {
+                case let .invite(_, _, _, _, memberCount, _), let .request(_, _, _, _, memberCount, _, _, _):
+                    return memberCount
+            }
+        }
+        
+        var isVerified: Bool {
+            switch self {
+            case .invite:
+                return false
+            case let .request(_, _, _, _, _, isVerified, _, _):
+                return isVerified
+            }
+        }
+        
+        var isFake: Bool {
+            switch self {
+            case .invite:
+                return false
+            case let .request(_, _, _, _, _, _, isFake, _):
+                return isFake
+            }
+        }
+        
+        var isScam: Bool {
+            switch self {
+            case .invite:
+                return false
+            case let .request(_, _, _, _, _, _, _, isScam):
+                return isScam
+            }
+        }
+    }
+    
+    private var contentDidBeginDragging: (() -> Void)?
+    private var contentOffsetUpdated: ((CGFloat, ContainedViewLayoutTransition) -> Void)?
+    
+    private let avatarNode: AvatarNode
+    private let titleNode: ImmediateTextNode
+    private var avatarIcon: ComponentView<Empty>?
+    private let countNode: ASTextNode
+    private let aboutNode: ASTextNode
+    private let descriptionNode: ASTextNode
+    private let peersScrollNode: ASScrollNode
+    
+    private let peerNodes: [SelectablePeerNode]
+    private let moreNode: MoreNode?
+    
+    private let actionButtonNode: SolidRoundedButtonNode
+    
+    private let context: AccountContext
+    private let content: Content
+    private let theme: PresentationTheme
+    private let strings: PresentationStrings
+    
+    var join: (() -> Void)?
+    
+    init(context: AccountContext, theme: PresentationTheme, strings: PresentationStrings, content: JoinLinkPreviewPeerContentNode.Content) {
+        self.context = context
+        self.content = content
+        self.theme = theme
+        self.strings = strings
+        
+        self.avatarNode = AvatarNode(font: avatarFont)
+        self.titleNode = ImmediateTextNode()
+        self.titleNode.maximumNumberOfLines = 2
+        self.titleNode.textAlignment = .center
+        self.countNode = ASTextNode()
+        self.aboutNode = ASTextNode()
+        self.aboutNode.maximumNumberOfLines = 8
+        self.aboutNode.textAlignment = .center
+        self.descriptionNode = ASTextNode()
+        self.descriptionNode.maximumNumberOfLines = 3
+        self.descriptionNode.textAlignment = .center
+        self.peersScrollNode = ASScrollNode()
+        self.peersScrollNode.view.showsHorizontalScrollIndicator = false
+        
+        self.actionButtonNode = SolidRoundedButtonNode(theme: SolidRoundedButtonTheme(theme: theme), height: 52.0, cornerRadius: 11.0)
+        
+        let itemTheme = SelectablePeerNodeTheme(textColor: theme.actionSheet.primaryTextColor, secretTextColor: .green, selectedTextColor: theme.actionSheet.controlAccentColor, checkBackgroundColor: theme.actionSheet.opaqueItemBackgroundColor, checkFillColor: theme.actionSheet.controlAccentColor, checkColor: theme.actionSheet.opaqueItemBackgroundColor, avatarPlaceholderColor: theme.list.mediaPlaceholderColor)
+        
+        if case let .invite(isGroup, _, _, _, memberCount, members) = content {
+            self.peerNodes = members.compactMap { peer in
+                guard peer.id != context.account.peerId else {
+                    return nil
+                }
+                let node = SelectablePeerNode()
+                node.setup(context: context, theme: theme, strings: strings, peer: EngineRenderedPeer(peer: peer), requiresPremiumForMessaging: false, synchronousLoad: false)
+                node.theme = itemTheme
+                return node
+            }
+            
+            if members.count < Int(memberCount) {
+                self.moreNode = MoreNode(count: Int(memberCount) - members.count)
+            } else {
+                self.moreNode = nil
+            }
+            
+            self.actionButtonNode.title = isGroup ? strings.Invitation_JoinGroup : strings.Channel_JoinChannel
+        } else {
+            self.peerNodes = []
+            self.moreNode = nil
+            
+            self.actionButtonNode.title = content.isGroup ? strings.MemberRequests_RequestToJoinGroup : strings.MemberRequests_RequestToJoinChannel
+        }
+        
+        super.init()
+        
+        let peer = TelegramGroup(id: EnginePeer.Id(0), title: content.title, photo: content.image.flatMap { [$0] } ?? [], participantCount: Int(content.memberCount), role: .member, membership: .Left, flags: [], defaultBannedRights: nil, migrationReference: nil, creationDate: 0, version: 0)
+        
+        self.addSubnode(self.avatarNode)
+        self.avatarNode.setPeer(context: context, theme: theme, peer: EnginePeer(peer), emptyColor: theme.list.mediaPlaceholderColor)
+        
+        self.addSubnode(self.titleNode)
+        self.titleNode.attributedText = NSAttributedString(string: content.title, font: Font.semibold(24.0), textColor: theme.actionSheet.primaryTextColor, paragraphAlignment: .center)
+        
+        self.addSubnode(self.countNode)
+        let membersString: String
+        if content.isGroup {
+            if case let .invite(_, _, _, _, memberCount, members) = content, !members.isEmpty {
+                membersString = strings.Invitation_Members(memberCount)
+            } else {
+                membersString = strings.Conversation_StatusMembers(content.memberCount)
+            }
+        } else {
+            membersString = strings.Conversation_StatusSubscribers(content.memberCount)
+        }
+
+        self.countNode.attributedText = NSAttributedString(string: membersString, font: Font.regular(15.0), textColor: theme.actionSheet.secondaryTextColor, paragraphAlignment: .center)
+        
+        if !self.peerNodes.isEmpty {
+            for peerNode in peerNodes {
+                self.peersScrollNode.addSubnode(peerNode)
+            }
+            self.addSubnode(self.peersScrollNode)
+        }
+        self.moreNode.flatMap(self.peersScrollNode.addSubnode)
+        
+        switch content {
+        case let .invite(_, _, _, about, _, _):
+            if let about = about, !about.isEmpty {
+                self.aboutNode.attributedText = NSAttributedString(string: about, font: Font.regular(17.0), textColor: theme.actionSheet.primaryTextColor, paragraphAlignment: .center)
+                self.addSubnode(self.aboutNode)
+            }
+        case let .request(isGroup, _, _, about, _, _, _, _):
+            if let about = about, !about.isEmpty {
+                self.aboutNode.attributedText = NSAttributedString(string: about, font: Font.regular(17.0), textColor: theme.actionSheet.primaryTextColor, paragraphAlignment: .center)
+                self.addSubnode(self.aboutNode)
+            }
+            
+            self.descriptionNode.attributedText = NSAttributedString(string: isGroup ? strings.MemberRequests_RequestToJoinDescriptionGroup : strings.MemberRequests_RequestToJoinDescriptionChannel, font: Font.regular(15.0), textColor: theme.actionSheet.secondaryTextColor, paragraphAlignment: .center)
+            self.addSubnode(self.descriptionNode)
+        }
+        
+        self.actionButtonNode.pressed = { [weak self] in
+            self?.join?()
+            self?.actionButtonNode.transitionToProgress()
+        }
+        self.addSubnode(self.actionButtonNode)
+    }
+    
+    func activate() {
+    }
+    
+    func deactivate() {
+    }
+    
+    func setEnsurePeerVisibleOnLayout(_ peerId: EnginePeer.Id?) {
+    }
+    
+    func setDidBeginDragging(_ f: (() -> Void)?) {
+        self.contentDidBeginDragging = f
+    }
+    
+    func setContentOffsetUpdated(_ f: ((CGFloat, ContainedViewLayoutTransition) -> Void)?) {
+        self.contentOffsetUpdated = f
+    }
+    
+    func updateTheme(_ theme: PresentationTheme) {
+    
+    }
+    
+    func updateLayout(size: CGSize, isLandscape: Bool, bottomInset: CGFloat, transition: ContainedViewLayoutTransition) {
+        let showPeers = !self.peerNodes.isEmpty && !isLandscape
+        var nodeHeight: CGFloat = (!showPeers ? 236.0 : 320.0)
+        let paddedSize = CGSize(width: size.width - 60.0, height: size.height)
+        
+        self.peersScrollNode.isHidden = !showPeers
+        
+        var aboutSize: CGSize?
+        var descriptionSize: CGSize?
+        if self.aboutNode.supernode != nil {
+            if isLandscape {
+                self.aboutNode.maximumNumberOfLines = 3
+            } else {
+                self.aboutNode.maximumNumberOfLines = 8
+            }
+            let measuredSize = self.aboutNode.measure(paddedSize)
+            nodeHeight += measuredSize.height + 20.0
+            aboutSize = measuredSize
+        }
+        
+        if isLandscape {
+            self.descriptionNode.removeFromSupernode()
+        } else if self.descriptionNode.supernode == nil {
+            self.addSubnode(self.descriptionNode)
+        }
+        if self.descriptionNode.supernode != nil {
+            let measuredSize = self.descriptionNode.measure(paddedSize)
+            nodeHeight += measuredSize.height + 20.0 + 10.0
+            descriptionSize = measuredSize
+        }
+        
+        let constrainSize = CGSize(width: size.width - 32.0, height: size.height)
+        
+        var statusIcon: EmojiStatusComponent.Content?
+        var constrainedTextSize = constrainSize
+        if self.content.isFake {
+            statusIcon = .text(color: self.theme.chat.message.incoming.scamColor, string: self.strings.Message_FakeAccount.uppercased())
+            constrainedTextSize.width -= 32.0
+        } else if self.content.isScam {
+            statusIcon = .text(color: self.theme.chat.message.incoming.scamColor, string: self.strings.Message_ScamAccount.uppercased())
+            constrainedTextSize.width -= 32.0
+        } else if self.content.isVerified {
+            statusIcon = .verified(fillColor: self.theme.list.itemCheckColors.fillColor, foregroundColor: self.theme.list.itemCheckColors.foregroundColor, sizeType: .compact)
+            constrainedTextSize.width -= 24.0
+        }
+        
+        let titleInfo = self.titleNode.updateLayoutFullInfo(constrainedTextSize)
+        let titleSize = titleInfo.size
+        nodeHeight += titleSize.height
+        
+        let verticalOrigin = size.height - nodeHeight
+        
+        let avatarSize: CGFloat = 100.0
+        
+        transition.updateFrame(node: self.avatarNode, frame: CGRect(origin: CGPoint(x: floor((size.width - avatarSize) / 2.0), y: verticalOrigin + 32.0), size: CGSize(width: avatarSize, height: avatarSize)))
+        
+        let titleFrame = CGRect(origin: CGPoint(x: floor((size.width - titleSize.width) / 2.0), y: verticalOrigin + 27.0 + avatarSize + 15.0), size: titleSize)
+        transition.updateFrame(node: self.titleNode, frame: titleFrame)
+        
+        if let statusIcon, let lastLine = titleInfo.linesRects().last {
+            let animationCache = self.context.animationCache
+            let animationRenderer = self.context.animationRenderer
+            
+            let avatarIcon: ComponentView<Empty>
+            var avatarIconTransition = ComponentTransition(transition)
+            if let current = self.avatarIcon {
+                avatarIcon = current
+            } else {
+                avatarIconTransition = avatarIconTransition.withAnimation(.none)
+                avatarIcon = ComponentView<Empty>()
+                self.avatarIcon = avatarIcon
+            }
+            
+            let avatarIconComponent = EmojiStatusComponent(
+                context: self.context,
+                animationCache: animationCache,
+                animationRenderer: animationRenderer,
+                content: statusIcon,
+                isVisibleForAnimations: true,
+                action: nil,
+                emojiFileUpdated: nil
+            )
+            let iconSize = avatarIcon.update(
+                transition: avatarIconTransition,
+                component: AnyComponent(avatarIconComponent),
+                environment: {},
+                containerSize: CGSize(width: 20.0, height: 20.0)
+            )
+            
+            if let avatarIconView = avatarIcon.view {
+                if avatarIconView.superview == nil {
+                    avatarIconView.isUserInteractionEnabled = false
+                    self.view.addSubview(avatarIconView)
+                }
+                
+                avatarIconTransition.setFrame(view: avatarIconView, frame: CGRect(origin: CGPoint(x: titleFrame.minX + floor((titleSize.width - lastLine.width) * 0.5) + lastLine.width + 5.0, y: 8.0 + titleFrame.minY + floorToScreenPixels(lastLine.midY - iconSize.height / 2.0) - lastLine.height), size: iconSize))
+            }
+        } else if let avatarIcon = self.avatarIcon {
+            self.avatarIcon = nil
+            avatarIcon.view?.removeFromSuperview()
+        }
+        
+        let countSize = self.countNode.measure(constrainSize)
+        transition.updateFrame(node: self.countNode, frame: CGRect(origin: CGPoint(x: floor((size.width - countSize.width) / 2.0), y: verticalOrigin + 27.0 + avatarSize + 15.0 + titleSize.height + 3.0), size: countSize))
+        
+        var verticalOffset = verticalOrigin + 27.0 + avatarSize + 15.0 + titleSize.height + 3.0 + countSize.height + 18.0
+                
+        let peerSize = CGSize(width: 85.0, height: 95.0)
+        let peerInset: CGFloat = 10.0
+        
+        var peerOffset = peerInset
+        for node in self.peerNodes {
+            node.frame = CGRect(origin: CGPoint(x: peerOffset, y: 0.0), size: peerSize)
+            peerOffset += peerSize.width
+        }
+        
+        if let moreNode = self.moreNode {
+            moreNode.updateLayout(size: peerSize)
+            moreNode.frame = CGRect(origin: CGPoint(x: peerOffset, y: 0.0), size: peerSize)
+            peerOffset += peerSize.width
+        }
+        
+        self.peersScrollNode.view.contentSize = CGSize(width: CGFloat(self.peerNodes.count) * peerSize.width + (self.moreNode != nil ? peerSize.width : 0.0) + peerInset * 2.0, height: peerSize.height)
+        transition.updateFrame(node: self.peersScrollNode, frame: CGRect(origin: CGPoint(x: 0.0, y: verticalOrigin + 27.0 + avatarSize + 15.0 + titleSize.height + 3.0 + countSize.height + 12.0), size: CGSize(width: size.width, height: peerSize.height)))
+        
+        if showPeers {
+            verticalOffset += 100.0
+        }
+        
+        if let aboutSize = aboutSize {
+            transition.updateFrame(node: self.aboutNode, frame: CGRect(origin: CGPoint(x: floor((size.width - aboutSize.width) / 2.0), y: verticalOffset), size: aboutSize))
+            verticalOffset += aboutSize.height + 20.0
+        }
+        
+        let buttonInset: CGFloat = 16.0
+        let actionButtonHeight = self.actionButtonNode.updateLayout(width: size.width - buttonInset * 2.0, transition: transition)
+        transition.updateFrame(node: self.actionButtonNode, frame: CGRect(x: buttonInset, y: verticalOffset, width: size.width, height: actionButtonHeight))
+        verticalOffset += actionButtonHeight + 20.0
+        
+        if let descriptionSize = descriptionSize {
+            transition.updateFrame(node: self.descriptionNode, frame: CGRect(origin: CGPoint(x: floor((size.width - descriptionSize.width) / 2.0), y: verticalOffset), size: descriptionSize))
+        }
+            
+        self.contentOffsetUpdated?(-size.height + nodeHeight, transition)
+    }
+    
+    func updateSelectedPeers(animated: Bool) {
+    }
+}
+
+public enum ShareLoadingState {
+    case preparing
+    case progress(Float)
+    case done
+}
+
+public final class JoinLinkPreviewLoadingContainerNode: ASDisplayNode, ShareContentContainerNode {
+    private var contentDidBeginDragging: (() -> Void)?
+    private var contentOffsetUpdated: ((CGFloat, ContainedViewLayoutTransition) -> Void)?
+    
+    private var theme: PresentationTheme
+    private let activityIndicator: ActivityIndicator
+    
+    public init(theme: PresentationTheme) {
+        self.theme = theme
+        self.activityIndicator = ActivityIndicator(type: .custom(theme.actionSheet.controlAccentColor, 22.0, 2.0, false))
+        
+        super.init()
+        
+        self.addSubnode(self.activityIndicator)
+    }
+    
+    public func activate() {
+    }
+    
+    public func deactivate() {
+    }
+    
+    public func setEnsurePeerVisibleOnLayout(_ peerId: EnginePeer.Id?) {
+    }
+    
+    public func setDidBeginDragging(_ f: (() -> Void)?) {
+        self.contentDidBeginDragging = f
+    }
+    
+    public func setContentOffsetUpdated(_ f: ((CGFloat, ContainedViewLayoutTransition) -> Void)?) {
+        self.contentOffsetUpdated = f
+    }
+    
+    public func updateTheme(_ theme: PresentationTheme) {
+        self.theme = theme
+        self.activityIndicator.type = .custom(theme.actionSheet.controlAccentColor, 22.0, 2.0, false)
+    }
+    
+    public func updateLayout(size: CGSize, isLandscape: Bool, bottomInset: CGFloat, transition: ContainedViewLayoutTransition) {
+        let nodeHeight: CGFloat = 125.0
+        
+        let indicatorSize = self.activityIndicator.calculateSizeThatFits(size)
+        let indicatorFrame = CGRect(origin: CGPoint(x: floor((size.width - indicatorSize.width) / 2.0), y: size.height - nodeHeight + floor((nodeHeight - indicatorSize.height) / 2.0)), size: indicatorSize)
+        transition.updateFrame(node: self.activityIndicator, frame: indicatorFrame)
+        
+        self.contentOffsetUpdated?(-size.height + nodeHeight, transition)
+    }
+    
+    public func updateSelectedPeers(animated: Bool) {
+    }
+}