Merge commit '7621e2f8dec938cf48181c8b10afc9b01f444e68' into beta

submodules/TelegramUI/Components/Calls/CallScreen/Sources/Animation/Animation.swift

@@ -0,0 +1,170 @@
+import Foundation
+import UIKit
+
+public enum AnimationCurve {
+    case linear
+    case easeInOut
+    case spring
+}
+
+extension AnimationCurve {
+    func map(_ fraction: CGFloat) -> CGFloat {
+        switch self {
+        case .linear:
+            return fraction
+        case .easeInOut:
+            return bezierPoint(0.42, 0.0, 0.58, 1.0, fraction)
+        case .spring:
+            return bezierPoint(0.23, 1.0, 0.32, 1.0, fraction)
+        }
+    }
+}
+
+open class AnyAnimation {
+}
+
+open class AnimationInterpolator<T> {
+    private let impl: (T, T, CGFloat) -> T
+    
+    init(_ impl: @escaping (T, T, CGFloat) -> T) {
+        self.impl = impl
+    }
+    
+    public func interpolate(from: T, to: T, fraction: CGFloat) -> T {
+        return self.impl(from, to, fraction)
+    }
+}
+
+public protocol AnimationInterpolatable {
+    static var animationInterpolator: AnimationInterpolator<Self> { get }
+}
+
+private let CGFloatInterpolator = AnimationInterpolator<CGFloat> { from, to, fraction in
+    return from * (1.0 - fraction) + to * fraction
+}
+extension CGFloat: AnimationInterpolatable {
+    public static var animationInterpolator: AnimationInterpolator<CGFloat> {
+        return CGFloatInterpolator
+    }
+}
+
+private let CGPointInterpolator = AnimationInterpolator<CGPoint> { from, to, fraction in
+    return CGPoint(
+        x: CGFloatInterpolator.interpolate(from: from.x, to: to.x, fraction: fraction),
+        y: CGFloatInterpolator.interpolate(from: from.y, to: to.y, fraction: fraction)
+    )
+}
+extension CGPoint: AnimationInterpolatable {
+    public static var animationInterpolator: AnimationInterpolator<CGPoint> {
+        return CGPointInterpolator
+    }
+}
+
+#if targetEnvironment(simulator)
+@_silgen_name("UIAnimationDragCoefficient") func UIAnimationDragCoefficient() -> Float
+#endif
+
+public final class Animation<T: AnimationInterpolatable>: AnyAnimation {
+    private let from: T
+    private let to: T
+    private let duration: Double
+    private let curve: AnimationCurve
+    private let interpolator: AnimationInterpolator<T>
+    
+    private var startTime: Double?
+    public private(set) var isFinished: Bool = false
+    
+    var didStart: (() -> Void)?
+    
+    public init(from: T, to: T, duration: Double, curve: AnimationCurve) {
+        self.from = from
+        self.to = to
+        #if targetEnvironment(simulator)
+        self.duration = duration * Double(UIAnimationDragCoefficient())
+        #else
+        self.duration = duration
+        #endif
+        self.curve = curve
+        self.interpolator = T.animationInterpolator
+    }
+    
+    func start() {
+        self.startTime = CACurrentMediaTime()
+    }
+    
+    func update(at timestamp: Double) -> T {
+        guard let startTime = self.startTime else {
+            return self.from
+        }
+        if self.isFinished {
+            return self.to
+        }
+        let fraction = max(0.0, min(1.0, (timestamp - startTime) / self.duration))
+        if timestamp > startTime + self.duration {
+            self.isFinished = true
+        }
+        if fraction >= 1.0 {
+            return self.to
+        }
+        return self.interpolator.interpolate(from: self.from, to: self.to, fraction: self.curve.map(fraction))
+    }
+}
+
+public class AnyAnimatedProperty {
+    var didStartAnimation: (() -> Void)?
+    var hasRunningAnimation: Bool {
+        return false
+    }
+    
+    public func update() {
+    }
+}
+
+public final class AnimatedProperty<T: AnimationInterpolatable>: AnyAnimatedProperty {
+    private var animation: Animation<T>?
+    
+    override var hasRunningAnimation: Bool {
+        return self.animation != nil
+    }
+    
+    public private(set) var value: T
+    
+    public init(_ value: T) {
+        self.value = value
+    }
+    
+    public func animate(to: T, duration: Double, curve: AnimationCurve) {
+        let timestamp = CACurrentMediaTime()
+        
+        let fromValue: T
+        if let animation = self.animation {
+            fromValue = animation.update(at: timestamp)
+        } else {
+            fromValue = self.value
+        }
+        self.animation = Animation(from: fromValue, to: to, duration: duration, curve: curve)
+        self.animation?.start()
+        self.didStartAnimation?()
+    }
+    
+    public func animate(from: T, to: T, duration: Double, curve: AnimationCurve) {
+        self.value = from
+        self.animation = Animation(from: from, to: to, duration: duration, curve: curve)
+        self.animation?.start()
+        self.didStartAnimation?()
+    }
+    
+    public func set(to: T) {
+        self.animation = nil
+        self.value = to
+    }
+    
+    override public func update() {
+        if let animation = self.animation {
+            self.value = animation.update(at: CACurrentMediaTime())
+            if animation.isFinished {
+                self.animation = nil
+            }
+        }
+    }
+}

submodules/TelegramUI/Components/Calls/CallScreen/Sources/Animation/AnimationManager.swift

@@ -0,0 +1,51 @@
+import Foundation
+import UIKit
+import Display
+
+public final class ManagedAnimations {
+    private var displayLinkSubscription: SharedDisplayLinkDriver.Link?
+    
+    private var properties: [AnyAnimatedProperty] = []
+    
+    public var updated: (() -> Void)?
+    
+    public init() {
+    }
+    
+    public func add(property: AnyAnimatedProperty) {
+        self.properties.append(property)
+        property.didStartAnimation = { [weak self] in
+            guard let self else {
+                return
+            }
+            self.updateNeedAnimations()
+        }
+    }
+    
+    private func updateNeedAnimations() {
+        if self.displayLinkSubscription == nil {
+            self.displayLinkSubscription = SharedDisplayLinkDriver.shared.add { [weak self] _ in
+                guard let self else {
+                    return
+                }
+                self.update()
+            }
+        }
+    }
+    
+    private func update() {
+        var hasRunningAnimations = false
+        for property in self.properties {
+            property.update()
+            if property.hasRunningAnimation {
+                hasRunningAnimations = true
+            }
+        }
+        
+        if !hasRunningAnimations {
+            self.displayLinkSubscription = nil
+        }
+        
+        self.updated?()
+    }
+}

submodules/TelegramUI/Components/Calls/CallScreen/Sources/Animation/Bezier.swift

@@ -0,0 +1,53 @@
+import Foundation
+
+private func a(_ a1: CGFloat, _ a2: CGFloat) -> CGFloat
+{
+    return 1.0 - 3.0 * a2 + 3.0 * a1
+}
+
+private func b(_ a1: CGFloat, _ a2: CGFloat) -> CGFloat
+{
+    return 3.0 * a2 - 6.0 * a1
+}
+
+private func c(_ a1: CGFloat) -> CGFloat
+{
+    return 3.0 * a1
+}
+
+private func calcBezier(_ t: CGFloat, _ a1: CGFloat, _ a2: CGFloat) -> CGFloat
+{
+    return ((a(a1, a2)*t + b(a1, a2))*t + c(a1)) * t
+}
+
+private func calcSlope(_ t: CGFloat, _ a1: CGFloat, _ a2: CGFloat) -> CGFloat
+{
+    return 3.0 * a(a1, a2) * t * t + 2.0 * b(a1, a2) * t + c(a1)
+}
+
+private func getTForX(_ x: CGFloat, _ x1: CGFloat, _ x2: CGFloat) -> CGFloat {
+    var t = x
+    var i = 0
+    while i < 4 {
+        let currentSlope = calcSlope(t, x1, x2)
+        if currentSlope == 0.0 {
+            return t
+        } else {
+            let currentX = calcBezier(t, x1, x2) - x
+            t -= currentX / currentSlope
+        }
+        
+        i += 1
+    }
+    
+    return t
+}
+
+public func bezierPoint(_ x1: CGFloat, _ y1: CGFloat, _ x2: CGFloat, _ y2: CGFloat, _ x: CGFloat) -> CGFloat
+{
+    var value = calcBezier(getTForX(x, x1, x2), y1, y2)
+    if value >= 0.997 {
+        value = 1.0
+    }
+    return value
+}