Animated emoji

submodules/TelegramUI/Components/EmojiTextAttachmentView/BUILD

@@ -0,0 +1,26 @@
+load("@build_bazel_rules_swift//swift:swift.bzl", "swift_library")
+
+swift_library(
+    name = "EmojiTextAttachmentView",
+    module_name = "EmojiTextAttachmentView",
+    srcs = glob([
+        "Sources/**/*.swift",
+    ]),
+    copts = [
+        "-warnings-as-errors",
+    ],
+    deps = [
+        "//submodules/AsyncDisplayKit:AsyncDisplayKit",
+        "//submodules/Display:Display",
+        "//submodules/SSignalKit/SwiftSignalKit:SwiftSignalKit",
+        "//submodules/Postbox:Postbox",
+        "//submodules/TelegramCore:TelegramCore",
+        "//submodules/AnimatedStickerNode:AnimatedStickerNode",
+        "//submodules/TelegramAnimatedStickerNode:TelegramAnimatedStickerNode",
+        "//submodules/YuvConversion:YuvConversion",
+        "//submodules/AccountContext:AccountContext",
+    ],
+    visibility = [
+        "//visibility:public",
+    ],
+)

submodules/TelegramUI/Components/EmojiTextAttachmentView/Sources/EmojiTextAttachmentView.swift

@@ -0,0 +1,213 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import AnimatedStickerNode
+import TelegramAnimatedStickerNode
+import SwiftSignalKit
+import AccountContext
+import YuvConversion
+import TelegramCore
+import Postbox
+
+private final class InlineStickerItemLayer: SimpleLayer {
+    static let queue = Queue()
+    
+    private let file: TelegramMediaFile
+    private let source: AnimatedStickerNodeSource
+    private var frameSource: QueueLocalObject<AnimatedStickerDirectFrameSource>?
+    private var disposable: Disposable?
+    private var fetchDisposable: Disposable?
+    
+    private var isInHierarchyValue: Bool = false
+    var isVisibleForAnimations: Bool = false {
+        didSet {
+            self.updatePlayback()
+        }
+    }
+    private var displayLink: ConstantDisplayLinkAnimator?
+    
+    init(context: AccountContext, file: TelegramMediaFile) {
+        self.source = AnimatedStickerResourceSource(account: context.account, resource: file.resource, fitzModifier: nil, isVideo: false)
+        self.file = file
+        
+        super.init()
+        
+        let pathPrefix = context.account.postbox.mediaBox.shortLivedResourceCachePathPrefix(file.resource.id)
+        let width = Int(24 * UIScreenScale)
+        let height = Int(24 * UIScreenScale)
+        
+        let directDataPath = Atomic<String?>(value: nil)
+        let _ = (self.source.directDataPath(attemptSynchronously: true) |> take(1)).start(next: { result in
+            let _ = directDataPath.swap(result)
+        })
+        
+        if let directDataPath = directDataPath.with({ $0 }), let directData = try? Data(contentsOf: URL(fileURLWithPath: directDataPath), options: .alwaysMapped) {
+            let syncFrameSource = AnimatedStickerDirectFrameSource(queue: .mainQueue(), data: directData, width: width, height: height, cachePathPrefix: pathPrefix, useMetalCache: false, fitzModifier: nil)!
+            
+            if let animationFrame = syncFrameSource.takeFrame(draw: true) {
+                var image: UIImage?
+                
+                autoreleasepool {
+                    image = generateImagePixel(CGSize(width: CGFloat(animationFrame.width), height: CGFloat(animationFrame.height)), scale: 1.0, pixelGenerator: { _, pixelData, contextBytesPerRow in
+                        var data = animationFrame.data
+                        data.withUnsafeMutableBytes { bytes -> Void in
+                            guard let baseAddress = bytes.baseAddress else {
+                                return
+                            }
+                            switch animationFrame.type {
+                            case .argb:
+                                memcpy(pixelData, baseAddress.assumingMemoryBound(to: UInt8.self), bytes.count)
+                            case .yuva:
+                                if animationFrame.bytesPerRow <= 0 || animationFrame.height <= 0 || animationFrame.width <= 0 || animationFrame.bytesPerRow * animationFrame.height > bytes.count {
+                                    assert(false)
+                                    return
+                                }
+                                decodeYUVAToRGBA(baseAddress.assumingMemoryBound(to: UInt8.self), pixelData, Int32(animationFrame.width), Int32(animationFrame.height), Int32(contextBytesPerRow))
+                            default:
+                                break
+                            }
+                        }
+                    })
+                }
+                
+                if let image = image {
+                    self.contents = image.cgImage
+                }
+            }
+        }
+        
+        self.disposable = (self.source.directDataPath(attemptSynchronously: false)
+        |> filter { $0 != nil }
+        |> take(1)
+        |> deliverOn(InlineStickerItemLayer.queue)).start(next: { [weak self] path in
+            guard let directData = try? Data(contentsOf: URL(fileURLWithPath: path!), options: [.mappedRead]) else {
+                return
+            }
+            Queue.mainQueue().async {
+                guard let strongSelf = self else {
+                    return
+                }
+                strongSelf.frameSource = QueueLocalObject(queue: InlineStickerItemLayer.queue, generate: {
+                    return AnimatedStickerDirectFrameSource(queue: InlineStickerItemLayer.queue, data: directData, width: width, height: height, cachePathPrefix: pathPrefix, useMetalCache: false, fitzModifier: nil)!
+                })
+                strongSelf.updatePlayback()
+            }
+        })
+        
+        self.fetchDisposable = freeMediaFileInteractiveFetched(account: context.account, fileReference: .standalone(media: file)).start()
+    }
+    
+    override init(layer: Any) {
+        guard let layer = layer as? InlineStickerItemLayer else {
+            preconditionFailure()
+        }
+        self.source = layer.source
+        self.file = layer.file
+        
+        super.init(layer: layer)
+    }
+    
+    required public init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+    
+    deinit {
+        self.disposable?.dispose()
+        self.fetchDisposable?.dispose()
+    }
+    
+    override func action(forKey event: String) -> CAAction? {
+        if event == kCAOnOrderIn {
+            self.isInHierarchyValue = true
+        } else if event == kCAOnOrderOut {
+            self.isInHierarchyValue = false
+        }
+        self.updatePlayback()
+        return nullAction
+    }
+    
+    private func updatePlayback() {
+        let shouldBePlaying = self.isInHierarchyValue && self.isVisibleForAnimations && self.frameSource != nil
+        if shouldBePlaying != (self.displayLink != nil) {
+            if shouldBePlaying {
+                self.displayLink = ConstantDisplayLinkAnimator(update: { [weak self] in
+                    self?.loadNextFrame()
+                })
+                self.displayLink?.isPaused = false
+            } else {
+                self.displayLink?.invalidate()
+                self.displayLink = nil
+            }
+        }
+    }
+    
+    private var didRequestFrame = false
+    
+    private func loadNextFrame() {
+        guard let frameSource = self.frameSource else {
+            return
+        }
+        self.didRequestFrame = true
+        frameSource.with { [weak self] impl in
+            if let animationFrame = impl.takeFrame(draw: true) {
+                var image: UIImage?
+                
+                autoreleasepool {
+                    image = generateImagePixel(CGSize(width: CGFloat(animationFrame.width), height: CGFloat(animationFrame.height)), scale: 1.0, pixelGenerator: { _, pixelData, contextBytesPerRow in
+                        var data = animationFrame.data
+                        data.withUnsafeMutableBytes { bytes -> Void in
+                            guard let baseAddress = bytes.baseAddress else {
+                                return
+                            }
+                            switch animationFrame.type {
+                            case .argb:
+                                memcpy(pixelData, baseAddress.assumingMemoryBound(to: UInt8.self), bytes.count)
+                            case .yuva:
+                                if animationFrame.bytesPerRow <= 0 || animationFrame.height <= 0 || animationFrame.width <= 0 || animationFrame.bytesPerRow * animationFrame.height > bytes.count {
+                                    assert(false)
+                                    return
+                                }
+                                decodeYUVAToRGBA(baseAddress.assumingMemoryBound(to: UInt8.self), pixelData, Int32(animationFrame.width), Int32(animationFrame.height), Int32(contextBytesPerRow))
+                            default:
+                                break
+                            }
+                        }
+                    })
+                }
+                
+                if let image = image {
+                    Queue.mainQueue().async {
+                        guard let strongSelf = self else {
+                            return
+                        }
+                        strongSelf.contents = image.cgImage
+                    }
+                }
+            }
+        }
+    }
+}
+
+public final class EmojiTextAttachmentView: UIView {
+    private let contentLayer: InlineStickerItemLayer
+    
+    public init(context: AccountContext, file: TelegramMediaFile) {
+        self.contentLayer = InlineStickerItemLayer(context: context, file: file)
+        
+        super.init(frame: CGRect())
+        
+        self.layer.addSublayer(self.contentLayer)
+        self.contentLayer.isVisibleForAnimations = true
+    }
+    
+    required public init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+    
+    override public func layoutSubviews() {
+        super.layoutSubviews()
+        
+        self.contentLayer.frame = CGRect(origin: CGPoint(x: 0.0, y: -2.0), size: CGSize(width: self.bounds.width - 0.0, height: self.bounds.height + 9.0))
+    }
+}