Merge commit '7621e2f8dec938cf48181c8b10afc9b01f444e68' into beta

submodules/GameUI/BUILD

@@ -0,0 +1,25 @@
+load("@build_bazel_rules_swift//swift:swift.bzl", "swift_library")
+
+swift_library(
+    name = "GameUI",
+    module_name = "GameUI",
+    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/ShareController:ShareController",
+        "//submodules/UndoUI:UndoUI",
+    ],
+    visibility = [
+        "//visibility:public",
+    ],
+)

submodules/GameUI/Sources/GameController.swift

@@ -0,0 +1,93 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import TelegramCore
+import SwiftSignalKit
+import TelegramPresentationData
+import AccountContext
+
+public final class GameController: ViewController {
+    private var controllerNode: GameControllerNode {
+        return self.displayNode as! GameControllerNode
+    }
+    
+    private let context: AccountContext
+    private let url: String
+    private let message: EngineMessage?
+    
+    private var presentationData: PresentationData
+    
+    public init(context: AccountContext, url: String, message: EngineMessage?) {
+        self.context = context
+        self.url = url
+        self.message = message
+        
+        self.presentationData = context.sharedContext.currentPresentationData.with { $0 }
+        
+        super.init(navigationBarPresentationData: NavigationBarPresentationData(presentationData: self.presentationData))
+        
+        self.statusBar.statusBarStyle = self.presentationData.theme.rootController.statusBarStyle.style
+        
+        if let message = message {
+            self.navigationItem.rightBarButtonItem = UIBarButtonItem(image: PresentationResourcesRootController.navigationShareIcon(self.presentationData.theme), style: .plain, target: self, action: #selector(self.sharePressed))
+            
+            for media in message.media {
+                if let game = media as? TelegramMediaGame {
+                    let titleView = GameControllerTitleView(theme: self.presentationData.theme)
+                    
+                    var botPeer: EnginePeer?
+                    inner: for attribute in message.attributes {
+                        if let attribute = attribute as? InlineBotMessageAttribute, let peerId = attribute.peerId {
+                            botPeer = message.peers[peerId].flatMap(EnginePeer.init)
+                            break inner
+                        }
+                    }
+                    if botPeer == nil {
+                        botPeer = message.author
+                    }
+                    
+                    titleView.set(title: game.title, subtitle: "@\(botPeer?.addressName ?? "")")
+                    self.navigationItem.titleView = titleView
+                }
+            }
+        } else {
+            self.title = "App"
+        }
+    }
+    
+    required public init(coder aDecoder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+    
+    deinit {
+        assert(true)
+    }
+    
+    @objc private func closePressed() {
+        self.dismiss()
+    }
+    
+    @objc private func sharePressed() {
+        self.controllerNode.shareWithoutScore()
+    }
+    
+    override public func loadDisplayNode() {
+        self.displayNode = GameControllerNode(context: self.context, presentationData: self.presentationData, url: self.url, present: { [weak self] c, a in
+            self?.present(c, in: .window(.root), with: a)
+        }, message: self.message)
+    }
+    
+    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)
+    }
+    
+    override public var presentationController: UIPresentationController? {
+        get {
+            return nil
+        } set(value) {
+        }
+    }
+}

submodules/GameUI/Sources/GameControllerNode.swift

@@ -0,0 +1,184 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import WebKit
+import TelegramCore
+import SwiftSignalKit
+import TelegramPresentationData
+import AccountContext
+import ShareController
+import UndoUI
+
+private class WeakGameScriptMessageHandler: NSObject, WKScriptMessageHandler {
+    private let f: (WKScriptMessage) -> ()
+    
+    init(_ f: @escaping (WKScriptMessage) -> ()) {
+        self.f = f
+        
+        super.init()
+    }
+    
+    func userContentController(_ controller: WKUserContentController, didReceive scriptMessage: WKScriptMessage) {
+        self.f(scriptMessage)
+    }
+}
+
+final class GameControllerNode: ViewControllerTracingNode {
+    private var webView: WKWebView?
+    
+    private let context: AccountContext
+    var presentationData: PresentationData
+    private let present: (ViewController, Any?) -> Void
+    private let message: EngineMessage?
+    
+    init(context: AccountContext, presentationData: PresentationData, url: String, present: @escaping (ViewController, Any?) -> Void, message: EngineMessage?) {
+        self.context = context
+        self.presentationData = presentationData
+        self.present = present
+        self.message = message
+        
+        super.init()
+        
+        self.backgroundColor = .white
+        
+        let js = "var TelegramWebviewProxyProto = function() {}; " +
+            "TelegramWebviewProxyProto.prototype.postEvent = function(eventName, eventData) { " +
+            "window.webkit.messageHandlers.performAction.postMessage({'eventName': eventName, 'eventData': eventData}); " +
+            "}; " +
+        "var TelegramWebviewProxy = new TelegramWebviewProxyProto();"
+        
+        let configuration = WKWebViewConfiguration()
+        let userController = WKUserContentController()
+        
+        let userScript = WKUserScript(source: js, injectionTime: .atDocumentStart, forMainFrameOnly: false)
+        userController.addUserScript(userScript)
+        
+        userController.add(WeakGameScriptMessageHandler { [weak self] message in
+            if let strongSelf = self {
+                strongSelf.handleScriptMessage(message)
+            }
+        }, name: "performAction")
+        
+        configuration.userContentController = userController
+        
+        configuration.allowsInlineMediaPlayback = true
+        if #available(iOSApplicationExtension 10.0, iOS 10.0, *) {
+            configuration.mediaTypesRequiringUserActionForPlayback = []
+        } else {
+            configuration.mediaPlaybackRequiresUserAction = false
+        }
+        
+        let webView = WKWebView(frame: CGRect(), configuration: configuration)
+        if #available(iOSApplicationExtension 9.0, iOS 9.0, *) {
+            webView.allowsLinkPreview = false
+        }
+        if #available(iOSApplicationExtension 11.0, iOS 11.0, *) {
+            webView.scrollView.contentInsetAdjustmentBehavior = .never
+        }
+        webView.interactiveTransitionGestureRecognizerTest = { point -> Bool in
+            return point.x > 30.0
+        }
+        
+        self.view.addSubview(webView)
+        self.webView = webView
+        
+        if let parsedUrl = URL(string: url) {
+            webView.load(URLRequest(url: parsedUrl))
+        }
+    }
+    
+    func containerLayoutUpdated(_ layout: ContainerViewLayout, navigationBarHeight: CGFloat, transition: ContainedViewLayoutTransition) {
+        if let webView = self.webView {
+            webView.frame = CGRect(origin: CGPoint(x: 0.0, y: navigationBarHeight), size: CGSize(width: layout.size.width, height: max(1.0, layout.size.height - navigationBarHeight)))
+        }
+    }
+    
+    func animateIn() {
+        self.layer.animatePosition(from: CGPoint(x: self.layer.position.x, y: self.layer.position.y + self.layer.bounds.size.height), to: self.layer.position, duration: 0.5, timingFunction: kCAMediaTimingFunctionSpring)
+    }
+    
+    func animateOut(completion: (() -> Void)? = nil) {
+        self.layer.animatePosition(from: self.layer.position, to: CGPoint(x: self.layer.position.x, y: self.layer.position.y + self.layer.bounds.size.height), duration: 0.2, timingFunction: CAMediaTimingFunctionName.easeInEaseOut.rawValue, removeOnCompletion: false, completion: { _ in
+            completion?()
+        })
+    }
+    
+    private func shareData() -> (EnginePeer, String)? {
+        guard let message = self.message else {
+            return nil
+        }
+        var botPeer: EnginePeer?
+        var gameName: String?
+        for media in message.media {
+            if let game = media as? TelegramMediaGame {
+                inner: for attribute in message.attributes {
+                    if let attribute = attribute as? InlineBotMessageAttribute, let peerId = attribute.peerId {
+                        botPeer = message.peers[peerId].flatMap(EnginePeer.init)
+                        break inner
+                    }
+                }
+                if botPeer == nil {
+                    botPeer = message.author
+                }
+                
+                gameName = game.name
+            }
+        }
+        if let botPeer = botPeer, let gameName = gameName {
+            return (botPeer, gameName)
+        }
+        
+        return nil
+    }
+    
+    private func handleScriptMessage(_ message: WKScriptMessage) {
+        guard let body = message.body as? [String: Any] else {
+            return
+        }
+        
+        guard let eventName = body["eventName"] as? String else {
+            return
+        }
+        
+        if eventName == "share_game" || eventName == "share_score" {
+            if let (botPeer, gameName) = self.shareData(), let addressName = botPeer.addressName, !addressName.isEmpty, !gameName.isEmpty {
+                if eventName == "share_score" {
+                    self.present(ShareController(context: self.context, subject: .fromExternal(1, { [weak self] peerIds, threadIds, requireStars, text, account, _ in
+                        if let strongSelf = self, let message = strongSelf.message, let account = account as? ShareControllerAppAccountContext {
+                            let signals = peerIds.map { TelegramEngine(account: account.context.account).messages.forwardGameWithScore(messageId: message.id, to: $0, threadId: threadIds[$0], as: nil) }
+                            return .single(.preparing(false))
+                            |> castError(ShareControllerError.self)
+                            |> then(
+                                combineLatest(signals)
+                                |> castError(ShareControllerError.self)
+                                |> mapToSignal { _ -> Signal<ShareControllerExternalStatus, ShareControllerError> in return .complete() }
+                            )
+                            |> then(.single(.done))
+                        } else {
+                            return .single(.done)
+                        }
+                    }), showInChat: nil, externalShare: false, immediateExternalShare: false), nil)
+                } else {
+                    self.shareWithoutScore()
+                }
+            }
+        }
+    }
+    
+    func shareWithoutScore() {
+        if let (botPeer, gameName) = self.shareData(), let addressName = botPeer.addressName, !addressName.isEmpty, !gameName.isEmpty {
+            let url = "https://t.me/\(addressName)?game=\(gameName)"
+            
+            let context = self.context
+            let shareController = ShareController(context: context, subject: .url(url), showInChat: nil, externalShare: true)
+            shareController.actionCompleted = { [weak self] in
+                if let strongSelf = self {
+                    let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+                    strongSelf.present(UndoOverlayController(presentationData: presentationData, content: .linkCopied(title: nil, text: presentationData.strings.Conversation_LinkCopied), elevatedLayout: false, animateInAsReplacement: false, action: { _ in return false }), nil)
+                }
+            }
+            self.present(shareController, nil)
+        }
+    }
+}

submodules/GameUI/Sources/GameControllerTitleView.swift

@@ -0,0 +1,70 @@
+import Foundation
+import UIKit
+import AsyncDisplayKit
+import Display
+import TelegramCore
+import SwiftSignalKit
+import TelegramPresentationData
+
+final class GameControllerTitleView: UIView {
+    private var theme: PresentationTheme
+    
+    private let titleNode: ASTextNode
+    private let infoNode: ASTextNode
+    
+    init(theme: PresentationTheme) {
+        self.theme = theme
+        
+        self.titleNode = ASTextNode()
+        self.titleNode.displaysAsynchronously = false
+        self.titleNode.maximumNumberOfLines = 1
+        self.titleNode.truncationMode = .byTruncatingTail
+        self.titleNode.isOpaque = false
+        
+        self.infoNode = ASTextNode()
+        self.infoNode.displaysAsynchronously = false
+        self.infoNode.maximumNumberOfLines = 1
+        self.infoNode.truncationMode = .byTruncatingTail
+        self.infoNode.isOpaque = false
+        
+        super.init(frame: CGRect())
+        
+        self.addSubnode(self.titleNode)
+        self.addSubnode(self.infoNode)
+    }
+    
+    required init?(coder aDecoder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+    
+    func set(title: String, subtitle: String) {
+        self.titleNode.attributedText = NSAttributedString(string: title, font: Font.semibold(17.0), textColor: self.theme.rootController.navigationBar.primaryTextColor)
+        self.infoNode.attributedText = NSAttributedString(string: subtitle, font: Font.regular(13.0), textColor: self.theme.rootController.navigationBar.secondaryTextColor)
+    }
+    
+    override func layoutSubviews() {
+        super.layoutSubviews()
+        
+        let size = self.bounds.size
+        
+        if size.height > 40.0 {
+            let titleSize = self.titleNode.measure(size)
+            let infoSize = self.infoNode.measure(size)
+            let titleInfoSpacing: CGFloat = 0.0
+            
+            let combinedHeight = titleSize.height + infoSize.height + titleInfoSpacing
+            
+            self.titleNode.frame = CGRect(origin: CGPoint(x: floor((size.width - titleSize.width) / 2.0), y: floor((size.height - combinedHeight) / 2.0)), size: titleSize)
+            self.infoNode.frame = CGRect(origin: CGPoint(x: floor((size.width - infoSize.width) / 2.0), y: floor((size.height - combinedHeight) / 2.0) + titleSize.height + titleInfoSpacing), size: infoSize)
+        } else {
+            let titleSize = self.titleNode.measure(CGSize(width: floor(size.width / 2.0), height: size.height))
+            let infoSize = self.infoNode.measure(CGSize(width: floor(size.width / 2.0), height: size.height))
+            
+            let titleInfoSpacing: CGFloat = 8.0
+            let combinedWidth = titleSize.width + infoSize.width + titleInfoSpacing
+            
+            self.titleNode.frame = CGRect(origin: CGPoint(x: floor((size.width - combinedWidth) / 2.0), y: floor((size.height - titleSize.height) / 2.0)), size: titleSize)
+            self.infoNode.frame = CGRect(origin: CGPoint(x: floor((size.width - combinedWidth) / 2.0 + titleSize.width + titleInfoSpacing), y: floor((size.height - infoSize.height) / 2.0)), size: infoSize)
+        }
+    }
+}