mirror of
https://github.com/Swiftgram/Telegram-iOS.git
synced 2025-06-16 05:55:20 +00:00
1092 lines
49 KiB
Swift
1092 lines
49 KiB
Swift
import Foundation
|
|
import UIKit
|
|
import Display
|
|
import AsyncDisplayKit
|
|
import Postbox
|
|
import TelegramCore
|
|
import SyncCore
|
|
import SwiftSignalKit
|
|
import TelegramPresentationData
|
|
import TelegramUIPreferences
|
|
import TelegramAudio
|
|
import AccountContext
|
|
import LocalizedPeerData
|
|
import PhotoResources
|
|
import CallsEmoji
|
|
|
|
private final class IncomingVideoNode: ASDisplayNode {
|
|
private let videoView: UIView
|
|
private var effectView: UIVisualEffectView?
|
|
private var isBlurred: Bool = false
|
|
|
|
init(videoView: UIView) {
|
|
self.videoView = videoView
|
|
|
|
super.init()
|
|
|
|
self.view.addSubview(self.videoView)
|
|
}
|
|
|
|
func updateLayout(size: CGSize) {
|
|
self.videoView.frame = CGRect(origin: CGPoint(), size: size)
|
|
}
|
|
|
|
func updateIsBlurred(isBlurred: Bool) {
|
|
if self.isBlurred == isBlurred {
|
|
return
|
|
}
|
|
self.isBlurred = isBlurred
|
|
|
|
if isBlurred {
|
|
if self.effectView == nil {
|
|
let effectView = UIVisualEffectView()
|
|
self.effectView = effectView
|
|
effectView.frame = self.videoView.frame
|
|
self.view.addSubview(effectView)
|
|
}
|
|
UIView.animate(withDuration: 0.3, animations: {
|
|
self.effectView?.effect = UIBlurEffect(style: .dark)
|
|
})
|
|
} else if let effectView = self.effectView {
|
|
UIView.animate(withDuration: 0.3, animations: {
|
|
effectView.effect = nil
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
private final class OutgoingVideoNode: ASDisplayNode {
|
|
private let videoTransformContainer: ASDisplayNode
|
|
private let videoView: UIView
|
|
private let buttonNode: HighlightTrackingButtonNode
|
|
|
|
private var effectView: UIVisualEffectView?
|
|
private var isBlurred: Bool = false
|
|
private var isExpanded: Bool = false
|
|
|
|
var tapped: (() -> Void)?
|
|
|
|
init(videoView: UIView) {
|
|
self.videoTransformContainer = ASDisplayNode()
|
|
self.videoTransformContainer.clipsToBounds = true
|
|
self.videoView = videoView
|
|
self.videoView.layer.transform = CATransform3DMakeScale(-1.0, 1.0, 1.0)
|
|
|
|
self.buttonNode = HighlightTrackingButtonNode()
|
|
|
|
super.init()
|
|
|
|
self.videoTransformContainer.view.addSubview(self.videoView)
|
|
self.addSubnode(self.videoTransformContainer)
|
|
//self.addSubnode(self.buttonNode)
|
|
|
|
self.buttonNode.addTarget(self, action: #selector(self.buttonPressed), forControlEvents: .touchUpInside)
|
|
}
|
|
|
|
@objc func buttonPressed() {
|
|
self.tapped?()
|
|
}
|
|
|
|
func updateLayout(size: CGSize, isExpanded: Bool, transition: ContainedViewLayoutTransition) {
|
|
let videoFrame = CGRect(origin: CGPoint(), size: size)
|
|
self.buttonNode.frame = videoFrame
|
|
self.isExpanded = isExpanded
|
|
|
|
let previousVideoFrame = self.videoTransformContainer.frame
|
|
self.videoTransformContainer.frame = videoFrame
|
|
if transition.isAnimated && !videoFrame.height.isZero && !previousVideoFrame.height.isZero {
|
|
transition.animatePositionAdditive(node: self.videoTransformContainer, offset: CGPoint(x: previousVideoFrame.midX - videoFrame.midX, y: previousVideoFrame.midY - videoFrame.midY))
|
|
transition.animateTransformScale(node: self.videoTransformContainer, from: previousVideoFrame.height / videoFrame.height)
|
|
}
|
|
|
|
self.videoView.frame = videoFrame
|
|
|
|
transition.updateCornerRadius(layer: self.videoTransformContainer.layer, cornerRadius: isExpanded ? 0.0 : 16.0)
|
|
if let effectView = self.effectView {
|
|
transition.updateCornerRadius(layer: effectView.layer, cornerRadius: isExpanded ? 0.0 : 16.0)
|
|
}
|
|
}
|
|
|
|
func updateIsBlurred(isBlurred: Bool) {
|
|
if self.isBlurred == isBlurred {
|
|
return
|
|
}
|
|
self.isBlurred = isBlurred
|
|
|
|
if isBlurred {
|
|
if self.effectView == nil {
|
|
let effectView = UIVisualEffectView()
|
|
effectView.clipsToBounds = true
|
|
effectView.layer.cornerRadius = self.isExpanded ? 0.0 : 16.0
|
|
self.effectView = effectView
|
|
effectView.frame = self.videoView.frame
|
|
self.view.addSubview(effectView)
|
|
}
|
|
UIView.animate(withDuration: 0.3, animations: {
|
|
self.effectView?.effect = UIBlurEffect(style: .dark)
|
|
})
|
|
} else if let effectView = self.effectView {
|
|
UIView.animate(withDuration: 0.3, animations: {
|
|
effectView.effect = nil
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
final class CallControllerNode: ASDisplayNode, CallControllerNodeProtocol {
|
|
private enum VideoNodeCorner {
|
|
case topLeft
|
|
case topRight
|
|
case bottomLeft
|
|
case bottomRight
|
|
}
|
|
|
|
private let sharedContext: SharedAccountContext
|
|
private let account: Account
|
|
|
|
private let statusBar: StatusBar
|
|
|
|
private var presentationData: PresentationData
|
|
private var peer: Peer?
|
|
private let debugInfo: Signal<(String, String), NoError>
|
|
private var forceReportRating = false
|
|
private let easyDebugAccess: Bool
|
|
private let call: PresentationCall
|
|
|
|
private let containerNode: ASDisplayNode
|
|
|
|
private let imageNode: TransformImageNode
|
|
private let dimNode: ASDisplayNode
|
|
private var incomingVideoNode: IncomingVideoNode?
|
|
private var incomingVideoViewRequested: Bool = false
|
|
private var outgoingVideoNode: OutgoingVideoNode?
|
|
private var outgoingVideoViewRequested: Bool = false
|
|
private var outgoingVideoExplicitelyFullscreen: Bool = false
|
|
private var outgoingVideoNodeCorner: VideoNodeCorner = .bottomRight
|
|
private let backButtonArrowNode: ASImageNode
|
|
private let backButtonNode: HighlightableButtonNode
|
|
private let statusNode: CallControllerStatusNode
|
|
private let videoPausedNode: ImmediateTextNode
|
|
private let buttonsNode: CallControllerButtonsNode
|
|
private var keyPreviewNode: CallControllerKeyPreviewNode?
|
|
|
|
private var debugNode: CallDebugNode?
|
|
|
|
private var keyTextData: (Data, String)?
|
|
private let keyButtonNode: HighlightableButtonNode
|
|
|
|
private var validLayout: (ContainerViewLayout, CGFloat)?
|
|
|
|
var isMuted: Bool = false {
|
|
didSet {
|
|
self.buttonsNode.isMuted = self.isMuted
|
|
if let (layout, navigationBarHeight) = self.validLayout {
|
|
self.containerLayoutUpdated(layout, navigationBarHeight: navigationBarHeight, transition: .animated(duration: 0.3, curve: .easeInOut))
|
|
}
|
|
}
|
|
}
|
|
|
|
private var shouldStayHiddenUntilConnection: Bool = false
|
|
|
|
private var audioOutputState: ([AudioSessionOutput], currentOutput: AudioSessionOutput?)?
|
|
private var callState: PresentationCallState?
|
|
|
|
var toggleMute: (() -> Void)?
|
|
var setCurrentAudioOutput: ((AudioSessionOutput) -> Void)?
|
|
var beginAudioOuputSelection: (() -> Void)?
|
|
var acceptCall: (() -> Void)?
|
|
var endCall: (() -> Void)?
|
|
var setIsVideoPaused: ((Bool) -> Void)?
|
|
var back: (() -> Void)?
|
|
var presentCallRating: ((CallId) -> Void)?
|
|
var callEnded: ((Bool) -> Void)?
|
|
var dismissedInteractively: (() -> Void)?
|
|
|
|
private var isUIHidden: Bool = false
|
|
private var isVideoPaused: Bool = false
|
|
|
|
init(sharedContext: SharedAccountContext, account: Account, presentationData: PresentationData, statusBar: StatusBar, debugInfo: Signal<(String, String), NoError>, shouldStayHiddenUntilConnection: Bool = false, easyDebugAccess: Bool, call: PresentationCall) {
|
|
self.sharedContext = sharedContext
|
|
self.account = account
|
|
self.presentationData = presentationData
|
|
self.statusBar = statusBar
|
|
self.debugInfo = debugInfo
|
|
self.shouldStayHiddenUntilConnection = shouldStayHiddenUntilConnection
|
|
self.easyDebugAccess = easyDebugAccess
|
|
self.call = call
|
|
|
|
self.containerNode = ASDisplayNode()
|
|
if self.shouldStayHiddenUntilConnection {
|
|
self.containerNode.alpha = 0.0
|
|
}
|
|
|
|
self.imageNode = TransformImageNode()
|
|
self.imageNode.contentAnimations = [.subsequentUpdates]
|
|
self.dimNode = ASDisplayNode()
|
|
self.dimNode.isUserInteractionEnabled = false
|
|
self.dimNode.backgroundColor = UIColor(white: 0.0, alpha: 0.4)
|
|
|
|
self.backButtonArrowNode = ASImageNode()
|
|
self.backButtonArrowNode.displayWithoutProcessing = true
|
|
self.backButtonArrowNode.displaysAsynchronously = false
|
|
self.backButtonArrowNode.image = NavigationBarTheme.generateBackArrowImage(color: .white)
|
|
self.backButtonNode = HighlightableButtonNode()
|
|
|
|
self.statusNode = CallControllerStatusNode()
|
|
|
|
self.videoPausedNode = ImmediateTextNode()
|
|
self.videoPausedNode.alpha = 0.0
|
|
|
|
self.buttonsNode = CallControllerButtonsNode(strings: self.presentationData.strings)
|
|
self.keyButtonNode = HighlightableButtonNode()
|
|
|
|
super.init()
|
|
|
|
self.setViewBlock({
|
|
return UITracingLayerView()
|
|
})
|
|
|
|
self.containerNode.backgroundColor = .black
|
|
|
|
self.addSubnode(self.containerNode)
|
|
|
|
self.backButtonNode.setTitle(presentationData.strings.Common_Back, with: Font.regular(17.0), with: .white, for: [])
|
|
self.backButtonNode.hitTestSlop = UIEdgeInsets(top: -8.0, left: -20.0, bottom: -8.0, right: -8.0)
|
|
self.backButtonNode.highligthedChanged = { [weak self] highlighted in
|
|
if let strongSelf = self {
|
|
if highlighted {
|
|
strongSelf.backButtonNode.layer.removeAnimation(forKey: "opacity")
|
|
strongSelf.backButtonArrowNode.layer.removeAnimation(forKey: "opacity")
|
|
strongSelf.backButtonNode.alpha = 0.4
|
|
strongSelf.backButtonArrowNode.alpha = 0.4
|
|
} else {
|
|
strongSelf.backButtonNode.alpha = 1.0
|
|
strongSelf.backButtonArrowNode.alpha = 1.0
|
|
strongSelf.backButtonNode.layer.animateAlpha(from: 0.4, to: 1.0, duration: 0.2)
|
|
strongSelf.backButtonArrowNode.layer.animateAlpha(from: 0.4, to: 1.0, duration: 0.2)
|
|
}
|
|
}
|
|
}
|
|
|
|
self.containerNode.addSubnode(self.imageNode)
|
|
self.containerNode.addSubnode(self.dimNode)
|
|
self.containerNode.addSubnode(self.statusNode)
|
|
self.containerNode.addSubnode(self.videoPausedNode)
|
|
self.containerNode.addSubnode(self.buttonsNode)
|
|
self.containerNode.addSubnode(self.keyButtonNode)
|
|
self.containerNode.addSubnode(self.backButtonArrowNode)
|
|
self.containerNode.addSubnode(self.backButtonNode)
|
|
|
|
self.buttonsNode.mute = { [weak self] in
|
|
self?.toggleMute?()
|
|
}
|
|
|
|
self.buttonsNode.speaker = { [weak self] in
|
|
self?.beginAudioOuputSelection?()
|
|
}
|
|
|
|
self.buttonsNode.end = { [weak self] in
|
|
self?.endCall?()
|
|
}
|
|
|
|
self.buttonsNode.accept = { [weak self] in
|
|
self?.acceptCall?()
|
|
}
|
|
|
|
self.buttonsNode.toggleVideo = { [weak self] in
|
|
guard let strongSelf = self else {
|
|
return
|
|
}
|
|
strongSelf.isVideoPaused = !strongSelf.isVideoPaused
|
|
strongSelf.outgoingVideoNode?.updateIsBlurred(isBlurred: strongSelf.isVideoPaused)
|
|
strongSelf.buttonsNode.isCameraPaused = strongSelf.isVideoPaused
|
|
strongSelf.setIsVideoPaused?(strongSelf.isVideoPaused)
|
|
|
|
if let (layout, navigationBarHeight) = strongSelf.validLayout {
|
|
strongSelf.containerLayoutUpdated(layout, navigationBarHeight: navigationBarHeight, transition: .animated(duration: 0.3, curve: .easeInOut))
|
|
}
|
|
}
|
|
|
|
self.buttonsNode.rotateCamera = { [weak self] in
|
|
self?.call.switchVideoCamera()
|
|
}
|
|
|
|
self.keyButtonNode.addTarget(self, action: #selector(self.keyPressed), forControlEvents: .touchUpInside)
|
|
|
|
self.backButtonNode.addTarget(self, action: #selector(self.backPressed), forControlEvents: .touchUpInside)
|
|
}
|
|
|
|
override func didLoad() {
|
|
super.didLoad()
|
|
|
|
let panRecognizer = UIPanGestureRecognizer(target: self, action: #selector(self.panGesture(_:)))
|
|
self.view.addGestureRecognizer(panRecognizer)
|
|
|
|
let tapRecognizer = UITapGestureRecognizer(target: self, action: #selector(self.tapGesture(_:)))
|
|
self.view.addGestureRecognizer(tapRecognizer)
|
|
}
|
|
|
|
func updatePeer(accountPeer: Peer, peer: Peer, hasOther: Bool) {
|
|
if !arePeersEqual(self.peer, peer) {
|
|
self.peer = peer
|
|
if let peerReference = PeerReference(peer), !peer.profileImageRepresentations.isEmpty {
|
|
let representations: [ImageRepresentationWithReference] = peer.profileImageRepresentations.map({ ImageRepresentationWithReference(representation: $0, reference: .avatar(peer: peerReference, resource: $0.resource)) })
|
|
self.imageNode.setSignal(chatAvatarGalleryPhoto(account: self.account, representations: representations, autoFetchFullSize: true))
|
|
self.dimNode.isHidden = false
|
|
} else {
|
|
self.imageNode.setSignal(callDefaultBackground())
|
|
self.dimNode.isHidden = true
|
|
}
|
|
|
|
self.statusNode.title = peer.displayTitle(strings: self.presentationData.strings, displayOrder: self.presentationData.nameDisplayOrder)
|
|
if hasOther {
|
|
self.statusNode.subtitle = self.presentationData.strings.Call_AnsweringWithAccount(accountPeer.displayTitle(strings: self.presentationData.strings, displayOrder: self.presentationData.nameDisplayOrder)).0
|
|
|
|
if let callState = callState {
|
|
self.updateCallState(callState)
|
|
}
|
|
}
|
|
|
|
self.videoPausedNode.attributedText = NSAttributedString(string: self.presentationData.strings.Call_RemoteVideoPaused(peer.compactDisplayTitle).0, font: Font.regular(17.0), textColor: .white)
|
|
|
|
if let (layout, navigationBarHeight) = self.validLayout {
|
|
self.containerLayoutUpdated(layout, navigationBarHeight: navigationBarHeight, transition: .immediate)
|
|
}
|
|
}
|
|
}
|
|
|
|
func updateAudioOutputs(availableOutputs: [AudioSessionOutput], currentOutput: AudioSessionOutput?) {
|
|
if self.audioOutputState?.0 != availableOutputs || self.audioOutputState?.1 != currentOutput {
|
|
self.audioOutputState = (availableOutputs, currentOutput)
|
|
self.updateButtonsMode()
|
|
}
|
|
}
|
|
|
|
func updateCallState(_ callState: PresentationCallState) {
|
|
self.callState = callState
|
|
|
|
let statusValue: CallControllerStatusValue
|
|
var statusReception: Int32?
|
|
|
|
switch callState.videoState {
|
|
case .active:
|
|
if !self.incomingVideoViewRequested {
|
|
self.incomingVideoViewRequested = true
|
|
self.call.makeIncomingVideoView(completion: { [weak self] incomingVideoView in
|
|
guard let strongSelf = self else {
|
|
return
|
|
}
|
|
if let incomingVideoView = incomingVideoView {
|
|
let incomingVideoNode = IncomingVideoNode(videoView: incomingVideoView)
|
|
strongSelf.incomingVideoNode = incomingVideoNode
|
|
strongSelf.containerNode.insertSubnode(incomingVideoNode, aboveSubnode: strongSelf.dimNode)
|
|
if let (layout, navigationBarHeight) = strongSelf.validLayout {
|
|
strongSelf.containerLayoutUpdated(layout, navigationBarHeight: navigationBarHeight, transition: .animated(duration: 0.5, curve: .spring))
|
|
}
|
|
}
|
|
})
|
|
}
|
|
default:
|
|
break
|
|
}
|
|
|
|
switch callState.videoState {
|
|
case .active, .activeOutgoing:
|
|
if !self.outgoingVideoViewRequested {
|
|
self.outgoingVideoViewRequested = true
|
|
self.call.makeOutgoingVideoView(completion: { [weak self] outgoingVideoView in
|
|
guard let strongSelf = self else {
|
|
return
|
|
}
|
|
if let outgoingVideoView = outgoingVideoView {
|
|
outgoingVideoView.backgroundColor = .black
|
|
outgoingVideoView.clipsToBounds = true
|
|
if let audioOutputState = strongSelf.audioOutputState, let currentOutput = audioOutputState.currentOutput {
|
|
switch currentOutput {
|
|
case .speaker, .builtin:
|
|
break
|
|
default:
|
|
strongSelf.setCurrentAudioOutput?(.speaker)
|
|
}
|
|
}
|
|
let outgoingVideoNode = OutgoingVideoNode(videoView: outgoingVideoView)
|
|
strongSelf.outgoingVideoNode = outgoingVideoNode
|
|
if let incomingVideoNode = strongSelf.incomingVideoNode {
|
|
strongSelf.containerNode.insertSubnode(outgoingVideoNode, aboveSubnode: incomingVideoNode)
|
|
} else {
|
|
strongSelf.containerNode.insertSubnode(outgoingVideoNode, aboveSubnode: strongSelf.dimNode)
|
|
}
|
|
if let (layout, navigationBarHeight) = strongSelf.validLayout {
|
|
strongSelf.containerLayoutUpdated(layout, navigationBarHeight: navigationBarHeight, transition: .animated(duration: 0.4, curve: .spring))
|
|
}
|
|
/*outgoingVideoNode.tapped = {
|
|
guard let strongSelf = self else {
|
|
return
|
|
}
|
|
strongSelf.outgoingVideoExplicitelyFullscreen = !strongSelf.outgoingVideoExplicitelyFullscreen
|
|
if let (layout, navigationBarHeight) = strongSelf.validLayout {
|
|
strongSelf.containerLayoutUpdated(layout, navigationBarHeight: navigationBarHeight, transition: .animated(duration: 0.4, curve: .spring))
|
|
}
|
|
}*/
|
|
}
|
|
})
|
|
}
|
|
default:
|
|
break
|
|
}
|
|
|
|
if let incomingVideoNode = self.incomingVideoNode {
|
|
let isActive: Bool
|
|
switch callState.remoteVideoState {
|
|
case .inactive:
|
|
isActive = false
|
|
case .active:
|
|
isActive = true
|
|
}
|
|
incomingVideoNode.updateIsBlurred(isBlurred: !isActive)
|
|
if isActive != self.videoPausedNode.alpha.isZero {
|
|
if isActive {
|
|
self.videoPausedNode.alpha = 0.0
|
|
self.videoPausedNode.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.3)
|
|
} else {
|
|
self.videoPausedNode.alpha = 1.0
|
|
self.videoPausedNode.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.3)
|
|
}
|
|
}
|
|
}
|
|
|
|
switch callState.state {
|
|
case .waiting, .connecting:
|
|
statusValue = .text(self.presentationData.strings.Call_StatusConnecting)
|
|
case let .requesting(ringing):
|
|
if ringing {
|
|
statusValue = .text(self.presentationData.strings.Call_StatusRinging)
|
|
} else {
|
|
statusValue = .text(self.presentationData.strings.Call_StatusRequesting)
|
|
}
|
|
case .terminating:
|
|
statusValue = .text(self.presentationData.strings.Call_StatusEnded)
|
|
case let .terminated(_, reason, _):
|
|
if let reason = reason {
|
|
switch reason {
|
|
case let .ended(type):
|
|
switch type {
|
|
case .busy:
|
|
statusValue = .text(self.presentationData.strings.Call_StatusBusy)
|
|
case .hungUp, .missed:
|
|
statusValue = .text(self.presentationData.strings.Call_StatusEnded)
|
|
}
|
|
case .error:
|
|
statusValue = .text(self.presentationData.strings.Call_StatusFailed)
|
|
}
|
|
} else {
|
|
statusValue = .text(self.presentationData.strings.Call_StatusEnded)
|
|
}
|
|
case .ringing:
|
|
var text = self.presentationData.strings.Call_StatusIncoming
|
|
if !self.statusNode.subtitle.isEmpty {
|
|
text += "\n\(self.statusNode.subtitle)"
|
|
}
|
|
statusValue = .text(text)
|
|
case .active(let timestamp, let reception, let keyVisualHash), .reconnecting(let timestamp, let reception, let keyVisualHash):
|
|
let strings = self.presentationData.strings
|
|
var isReconnecting = false
|
|
if case .reconnecting = callState.state {
|
|
isReconnecting = true
|
|
}
|
|
statusValue = .timer({ value in
|
|
if isReconnecting {
|
|
return strings.Call_StatusConnecting
|
|
} else {
|
|
return value
|
|
}
|
|
}, timestamp)
|
|
if self.keyTextData?.0 != keyVisualHash {
|
|
let text = stringForEmojiHashOfData(keyVisualHash, 4)!
|
|
self.keyTextData = (keyVisualHash, text)
|
|
|
|
self.keyButtonNode.setAttributedTitle(NSAttributedString(string: text, attributes: [NSAttributedString.Key.font: Font.regular(22.0), NSAttributedString.Key.kern: 2.5 as NSNumber]), for: [])
|
|
|
|
let keyTextSize = self.keyButtonNode.measure(CGSize(width: 200.0, height: 200.0))
|
|
self.keyButtonNode.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.3)
|
|
self.keyButtonNode.frame = CGRect(origin: self.keyButtonNode.frame.origin, size: keyTextSize)
|
|
|
|
if let (layout, navigationBarHeight) = self.validLayout {
|
|
self.containerLayoutUpdated(layout, navigationBarHeight: navigationBarHeight, transition: .immediate)
|
|
}
|
|
}
|
|
statusReception = reception
|
|
}
|
|
switch callState.state {
|
|
case .terminated, .terminating:
|
|
if !self.statusNode.alpha.isEqual(to: 0.5) {
|
|
self.statusNode.alpha = 0.5
|
|
self.buttonsNode.alpha = 0.5
|
|
self.keyButtonNode.alpha = 0.5
|
|
self.backButtonArrowNode.alpha = 0.5
|
|
self.backButtonNode.alpha = 0.5
|
|
|
|
self.statusNode.layer.animateAlpha(from: 1.0, to: 0.5, duration: 0.25)
|
|
self.buttonsNode.layer.animateAlpha(from: 1.0, to: 0.5, duration: 0.25)
|
|
self.keyButtonNode.layer.animateAlpha(from: 1.0, to: 0.5, duration: 0.25)
|
|
}
|
|
default:
|
|
if !self.statusNode.alpha.isEqual(to: 1.0) {
|
|
self.statusNode.alpha = 1.0
|
|
self.buttonsNode.alpha = 1.0
|
|
self.keyButtonNode.alpha = 1.0
|
|
self.backButtonArrowNode.alpha = 1.0
|
|
self.backButtonNode.alpha = 1.0
|
|
}
|
|
}
|
|
if self.shouldStayHiddenUntilConnection {
|
|
switch callState.state {
|
|
case .connecting, .active:
|
|
self.containerNode.alpha = 1.0
|
|
default:
|
|
break
|
|
}
|
|
}
|
|
self.statusNode.status = statusValue
|
|
self.statusNode.reception = statusReception
|
|
|
|
self.updateButtonsMode()
|
|
|
|
if case let .terminated(id, _, reportRating) = callState.state, let callId = id {
|
|
let presentRating = reportRating || self.forceReportRating
|
|
if presentRating {
|
|
self.presentCallRating?(callId)
|
|
}
|
|
self.callEnded?(presentRating)
|
|
}
|
|
}
|
|
|
|
private var buttonsTerminationMode: CallControllerButtonsMode?
|
|
|
|
private func updateButtonsMode() {
|
|
guard let callState = self.callState else {
|
|
return
|
|
}
|
|
|
|
var mode: CallControllerButtonsSpeakerMode = .none
|
|
if let (availableOutputs, maybeCurrentOutput) = self.audioOutputState, let currentOutput = maybeCurrentOutput {
|
|
switch currentOutput {
|
|
case .builtin:
|
|
mode = .builtin
|
|
case .speaker:
|
|
mode = .speaker
|
|
case .headphones:
|
|
mode = .headphones
|
|
case .port:
|
|
mode = .bluetooth
|
|
}
|
|
if availableOutputs.count <= 1 {
|
|
mode = .none
|
|
}
|
|
}
|
|
let mappedVideoState: CallControllerButtonsMode.VideoState
|
|
switch callState.videoState {
|
|
case .notAvailable:
|
|
mappedVideoState = .notAvailable
|
|
case .available:
|
|
mappedVideoState = .available(true)
|
|
case .active:
|
|
mappedVideoState = .active
|
|
case .activeOutgoing:
|
|
mappedVideoState = .active
|
|
}
|
|
|
|
switch callState.state {
|
|
case .ringing:
|
|
let buttonsMode: CallControllerButtonsMode = .incoming(speakerMode: mode, videoState: mappedVideoState)
|
|
self.buttonsNode.updateMode(strings: self.presentationData.strings, mode: buttonsMode)
|
|
self.buttonsTerminationMode = buttonsMode
|
|
case .waiting, .requesting:
|
|
let buttonsMode: CallControllerButtonsMode = .outgoingRinging(speakerMode: mode, videoState: mappedVideoState)
|
|
self.buttonsNode.updateMode(strings: self.presentationData.strings, mode: buttonsMode)
|
|
self.buttonsTerminationMode = buttonsMode
|
|
case .active, .connecting, .reconnecting:
|
|
let buttonsMode: CallControllerButtonsMode = .active(speakerMode: mode, videoState: mappedVideoState)
|
|
self.buttonsNode.updateMode(strings: self.presentationData.strings, mode: buttonsMode)
|
|
self.buttonsTerminationMode = buttonsMode
|
|
case .terminating, .terminated:
|
|
if let buttonsTerminationMode = self.buttonsTerminationMode {
|
|
self.buttonsNode.updateMode(strings: self.presentationData.strings, mode: buttonsTerminationMode)
|
|
} else {
|
|
self.buttonsNode.updateMode(strings: self.presentationData.strings, mode: .active(speakerMode: mode, videoState: mappedVideoState))
|
|
}
|
|
}
|
|
}
|
|
|
|
func animateIn() {
|
|
var bounds = self.bounds
|
|
bounds.origin = CGPoint()
|
|
self.bounds = bounds
|
|
self.layer.removeAnimation(forKey: "bounds")
|
|
self.statusBar.layer.removeAnimation(forKey: "opacity")
|
|
self.containerNode.layer.removeAnimation(forKey: "opacity")
|
|
self.containerNode.layer.removeAnimation(forKey: "scale")
|
|
self.statusBar.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.3)
|
|
if !self.shouldStayHiddenUntilConnection {
|
|
self.containerNode.layer.animateScale(from: 1.04, to: 1.0, duration: 0.3)
|
|
self.containerNode.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.2)
|
|
}
|
|
}
|
|
|
|
func animateOut(completion: @escaping () -> Void) {
|
|
self.statusBar.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.3, removeOnCompletion: false)
|
|
if !self.shouldStayHiddenUntilConnection || self.containerNode.alpha > 0.0 {
|
|
self.containerNode.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.3, removeOnCompletion: false)
|
|
self.containerNode.layer.animateScale(from: 1.0, to: 1.04, duration: 0.3, removeOnCompletion: false, completion: { _ in
|
|
completion()
|
|
})
|
|
} else {
|
|
completion()
|
|
}
|
|
}
|
|
|
|
private func calculatePreviewVideoRect(layout: ContainerViewLayout, navigationHeight: CGFloat) -> CGRect {
|
|
let buttonsHeight: CGFloat = 190.0
|
|
let buttonsOffset: CGFloat
|
|
if layout.size.width.isEqual(to: 320.0) {
|
|
if layout.size.height.isEqual(to: 480.0) {
|
|
buttonsOffset = 60.0
|
|
} else {
|
|
buttonsOffset = 73.0
|
|
}
|
|
} else {
|
|
buttonsOffset = 83.0
|
|
}
|
|
|
|
let buttonsOriginY: CGFloat
|
|
if self.isUIHidden {
|
|
buttonsOriginY = layout.size.height + 40.0 - 80.0
|
|
} else {
|
|
buttonsOriginY = layout.size.height - (buttonsOffset - 40.0) - buttonsHeight - layout.intrinsicInsets.bottom
|
|
}
|
|
|
|
let previewVideoSize = layout.size.aspectFitted(CGSize(width: 200.0, height: 200.0))
|
|
let previewVideoY: CGFloat
|
|
let previewVideoX: CGFloat
|
|
|
|
switch self.outgoingVideoNodeCorner {
|
|
case .topLeft:
|
|
previewVideoX = 20.0
|
|
if self.isUIHidden {
|
|
previewVideoY = layout.insets(options: .statusBar).top + 8.0
|
|
} else {
|
|
previewVideoY = layout.insets(options: .statusBar).top + 44.0 + 8.0
|
|
}
|
|
case .topRight:
|
|
previewVideoX = layout.size.width - previewVideoSize.width - 20.0
|
|
if self.isUIHidden {
|
|
previewVideoY = layout.insets(options: .statusBar).top + 8.0
|
|
} else {
|
|
previewVideoY = layout.insets(options: .statusBar).top + 44.0 + 8.0
|
|
}
|
|
case .bottomLeft:
|
|
previewVideoX = 20.0
|
|
if self.isUIHidden {
|
|
previewVideoY = layout.size.height - layout.intrinsicInsets.bottom - 8.0 - previewVideoSize.height
|
|
} else {
|
|
previewVideoY = buttonsOriginY + 100.0 - previewVideoSize.height
|
|
}
|
|
case .bottomRight:
|
|
previewVideoX = layout.size.width - previewVideoSize.width - 20.0
|
|
if self.isUIHidden {
|
|
previewVideoY = layout.size.height - layout.intrinsicInsets.bottom - 8.0 - previewVideoSize.height
|
|
} else {
|
|
previewVideoY = buttonsOriginY + 100.0 - previewVideoSize.height
|
|
}
|
|
}
|
|
|
|
return CGRect(origin: CGPoint(x: previewVideoX, y: previewVideoY), size: previewVideoSize)
|
|
}
|
|
|
|
func containerLayoutUpdated(_ layout: ContainerViewLayout, navigationBarHeight: CGFloat, transition: ContainedViewLayoutTransition) {
|
|
self.validLayout = (layout, navigationBarHeight)
|
|
|
|
let overlayAlpha: CGFloat = self.isUIHidden ? 0.0 : 1.0
|
|
|
|
transition.updateFrame(node: self.containerNode, frame: CGRect(origin: CGPoint(), size: layout.size))
|
|
transition.updateFrame(node: self.dimNode, frame: CGRect(origin: CGPoint(), size: layout.size))
|
|
|
|
if let keyPreviewNode = self.keyPreviewNode {
|
|
transition.updateFrame(node: keyPreviewNode, frame: CGRect(origin: CGPoint(), size: layout.size))
|
|
keyPreviewNode.updateLayout(size: layout.size, transition: .immediate)
|
|
}
|
|
|
|
transition.updateFrame(node: self.imageNode, frame: CGRect(origin: CGPoint(), size: layout.size))
|
|
let arguments = TransformImageArguments(corners: ImageCorners(), imageSize: CGSize(width: 640.0, height: 640.0).aspectFilled(layout.size), boundingSize: layout.size, intrinsicInsets: UIEdgeInsets())
|
|
let apply = self.imageNode.asyncLayout()(arguments)
|
|
apply()
|
|
|
|
let navigationOffset: CGFloat = max(20.0, layout.safeInsets.top)
|
|
|
|
let backSize = self.backButtonNode.measure(CGSize(width: 320.0, height: 100.0))
|
|
if let image = self.backButtonArrowNode.image {
|
|
transition.updateFrame(node: self.backButtonArrowNode, frame: CGRect(origin: CGPoint(x: 10.0, y: navigationOffset + 11.0), size: image.size))
|
|
}
|
|
transition.updateFrame(node: self.backButtonNode, frame: CGRect(origin: CGPoint(x: 29.0, y: navigationOffset + 11.0), size: backSize))
|
|
|
|
transition.updateAlpha(node: self.backButtonArrowNode, alpha: overlayAlpha)
|
|
transition.updateAlpha(node: self.backButtonNode, alpha: overlayAlpha)
|
|
|
|
var statusOffset: CGFloat
|
|
if layout.metrics.widthClass == .regular && layout.metrics.heightClass == .regular {
|
|
if layout.size.height.isEqual(to: 1366.0) {
|
|
statusOffset = 160.0
|
|
} else {
|
|
statusOffset = 120.0
|
|
}
|
|
} else {
|
|
if layout.size.height.isEqual(to: 736.0) {
|
|
statusOffset = 80.0
|
|
} else if layout.size.width.isEqual(to: 320.0) {
|
|
statusOffset = 60.0
|
|
} else {
|
|
statusOffset = 64.0
|
|
}
|
|
}
|
|
|
|
statusOffset += layout.safeInsets.top
|
|
|
|
let buttonsHeight: CGFloat = 190.0
|
|
let buttonsOffset: CGFloat
|
|
if layout.size.width.isEqual(to: 320.0) {
|
|
if layout.size.height.isEqual(to: 480.0) {
|
|
buttonsOffset = 60.0
|
|
} else {
|
|
buttonsOffset = 73.0
|
|
}
|
|
} else {
|
|
buttonsOffset = 83.0
|
|
}
|
|
|
|
let statusHeight = self.statusNode.updateLayout(constrainedWidth: layout.size.width, transition: transition)
|
|
transition.updateFrame(node: self.statusNode, frame: CGRect(origin: CGPoint(x: 0.0, y: statusOffset), size: CGSize(width: layout.size.width, height: statusHeight)))
|
|
transition.updateAlpha(node: self.statusNode, alpha: overlayAlpha)
|
|
|
|
let videoPausedSize = self.videoPausedNode.updateLayout(CGSize(width: layout.size.width - 16.0, height: 100.0))
|
|
transition.updateFrame(node: self.videoPausedNode, frame: CGRect(origin: CGPoint(x: floor((layout.size.width - videoPausedSize.width) / 2.0), y: floor((layout.size.height - videoPausedSize.height) / 2.0)), size: videoPausedSize))
|
|
|
|
self.buttonsNode.updateLayout(strings: self.presentationData.strings, constrainedWidth: layout.size.width, transition: transition)
|
|
let buttonsOriginY: CGFloat
|
|
if self.isUIHidden {
|
|
buttonsOriginY = layout.size.height + 40.0 - 80.0
|
|
} else {
|
|
buttonsOriginY = layout.size.height - (buttonsOffset - 40.0) - buttonsHeight - layout.intrinsicInsets.bottom
|
|
}
|
|
transition.updateFrame(node: self.buttonsNode, frame: CGRect(origin: CGPoint(x: 0.0, y: buttonsOriginY), size: CGSize(width: layout.size.width, height: buttonsHeight)))
|
|
transition.updateAlpha(node: self.buttonsNode, alpha: overlayAlpha)
|
|
|
|
let fullscreenVideoFrame = CGRect(origin: CGPoint(), size: layout.size)
|
|
|
|
let previewVideoFrame = self.calculatePreviewVideoRect(layout: layout, navigationHeight: navigationBarHeight)
|
|
|
|
if let incomingVideoNode = self.incomingVideoNode {
|
|
var incomingVideoTransition = transition
|
|
if incomingVideoNode.frame.isEmpty {
|
|
incomingVideoTransition = .immediate
|
|
}
|
|
if self.outgoingVideoExplicitelyFullscreen {
|
|
incomingVideoTransition.updateFrame(node: incomingVideoNode, frame: previewVideoFrame)
|
|
} else {
|
|
incomingVideoTransition.updateFrame(node: incomingVideoNode, frame: fullscreenVideoFrame)
|
|
}
|
|
incomingVideoNode.updateLayout(size: incomingVideoNode.frame.size)
|
|
}
|
|
if let outgoingVideoNode = self.outgoingVideoNode {
|
|
var outgoingVideoTransition = transition
|
|
if outgoingVideoNode.frame.isEmpty {
|
|
outgoingVideoTransition = .immediate
|
|
}
|
|
if self.incomingVideoNode == nil {
|
|
outgoingVideoNode.frame = fullscreenVideoFrame
|
|
outgoingVideoNode.updateLayout(size: layout.size, isExpanded: true, transition: outgoingVideoTransition)
|
|
} else {
|
|
if self.minimizedVideoDraggingPosition == nil {
|
|
if self.outgoingVideoExplicitelyFullscreen {
|
|
outgoingVideoTransition.updateFrame(node: outgoingVideoNode, frame: fullscreenVideoFrame)
|
|
} else {
|
|
outgoingVideoTransition.updateFrame(node: outgoingVideoNode, frame: previewVideoFrame)
|
|
}
|
|
outgoingVideoNode.updateLayout(size: outgoingVideoNode.frame.size, isExpanded: self.outgoingVideoExplicitelyFullscreen, transition: outgoingVideoTransition)
|
|
}
|
|
}
|
|
}
|
|
|
|
let keyTextSize = self.keyButtonNode.frame.size
|
|
transition.updateFrame(node: self.keyButtonNode, frame: CGRect(origin: CGPoint(x: layout.size.width - keyTextSize.width - 8.0, y: navigationOffset + 8.0), size: keyTextSize))
|
|
transition.updateAlpha(node: self.keyButtonNode, alpha: overlayAlpha)
|
|
|
|
if let debugNode = self.debugNode {
|
|
transition.updateFrame(node: debugNode, frame: CGRect(origin: CGPoint(), size: layout.size))
|
|
}
|
|
}
|
|
|
|
@objc func keyPressed() {
|
|
if self.keyPreviewNode == nil, let keyText = self.keyTextData?.1, let peer = self.peer {
|
|
let keyPreviewNode = CallControllerKeyPreviewNode(keyText: keyText, infoText: self.presentationData.strings.Call_EmojiDescription(peer.compactDisplayTitle).0.replacingOccurrences(of: "%%", with: "%"), dismiss: { [weak self] in
|
|
if let _ = self?.keyPreviewNode {
|
|
self?.backPressed()
|
|
}
|
|
})
|
|
|
|
self.containerNode.insertSubnode(keyPreviewNode, belowSubnode: self.statusNode)
|
|
self.keyPreviewNode = keyPreviewNode
|
|
|
|
if let (validLayout, _) = self.validLayout {
|
|
keyPreviewNode.updateLayout(size: validLayout.size, transition: .immediate)
|
|
|
|
self.keyButtonNode.isHidden = true
|
|
keyPreviewNode.animateIn(from: self.keyButtonNode.frame, fromNode: self.keyButtonNode)
|
|
}
|
|
}
|
|
}
|
|
|
|
@objc func backPressed() {
|
|
if let keyPreviewNode = self.keyPreviewNode {
|
|
self.keyPreviewNode = nil
|
|
keyPreviewNode.animateOut(to: self.keyButtonNode.frame, toNode: self.keyButtonNode, completion: { [weak self, weak keyPreviewNode] in
|
|
self?.keyButtonNode.isHidden = false
|
|
keyPreviewNode?.removeFromSupernode()
|
|
})
|
|
} else {
|
|
self.back?()
|
|
}
|
|
}
|
|
|
|
private var debugTapCounter: (Double, Int) = (0.0, 0)
|
|
|
|
@objc func tapGesture(_ recognizer: UITapGestureRecognizer) {
|
|
if case .ended = recognizer.state {
|
|
if let _ = self.keyPreviewNode {
|
|
self.backPressed()
|
|
} else {
|
|
if self.incomingVideoNode != nil || self.outgoingVideoNode != nil {
|
|
self.isUIHidden = !self.isUIHidden
|
|
if let (layout, navigationBarHeight) = self.validLayout {
|
|
self.containerLayoutUpdated(layout, navigationBarHeight: navigationBarHeight, transition: .animated(duration: 0.3, curve: .easeInOut))
|
|
}
|
|
} else {
|
|
let point = recognizer.location(in: recognizer.view)
|
|
if self.statusNode.frame.contains(point) {
|
|
if self.easyDebugAccess {
|
|
self.presentDebugNode()
|
|
} else {
|
|
let timestamp = CACurrentMediaTime()
|
|
if self.debugTapCounter.0 < timestamp - 0.75 {
|
|
self.debugTapCounter.0 = timestamp
|
|
self.debugTapCounter.1 = 0
|
|
}
|
|
|
|
if self.debugTapCounter.0 >= timestamp - 0.75 {
|
|
self.debugTapCounter.0 = timestamp
|
|
self.debugTapCounter.1 += 1
|
|
}
|
|
|
|
if self.debugTapCounter.1 >= 10 {
|
|
self.debugTapCounter.1 = 0
|
|
|
|
self.presentDebugNode()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private func presentDebugNode() {
|
|
guard self.debugNode == nil else {
|
|
return
|
|
}
|
|
|
|
self.forceReportRating = true
|
|
|
|
let debugNode = CallDebugNode(signal: self.debugInfo)
|
|
debugNode.dismiss = { [weak self] in
|
|
if let strongSelf = self {
|
|
strongSelf.debugNode?.removeFromSupernode()
|
|
strongSelf.debugNode = nil
|
|
}
|
|
}
|
|
self.addSubnode(debugNode)
|
|
self.debugNode = debugNode
|
|
|
|
if let (layout, navigationBarHeight) = self.validLayout {
|
|
self.containerLayoutUpdated(layout, navigationBarHeight: navigationBarHeight, transition: .immediate)
|
|
}
|
|
}
|
|
|
|
private var minimizedVideoInitialPosition: CGPoint?
|
|
private var minimizedVideoDraggingPosition: CGPoint?
|
|
|
|
private func nodeLocationForPosition(layout: ContainerViewLayout, position: CGPoint, velocity: CGPoint) -> VideoNodeCorner {
|
|
let layoutInsets = UIEdgeInsets()
|
|
var result = CGPoint()
|
|
if position.x < layout.size.width / 2.0 {
|
|
result.x = 0.0
|
|
} else {
|
|
result.x = 1.0
|
|
}
|
|
if position.y < layoutInsets.top + (layout.size.height - layoutInsets.bottom - layoutInsets.top) / 2.0 {
|
|
result.y = 0.0
|
|
} else {
|
|
result.y = 1.0
|
|
}
|
|
|
|
let currentPosition = result
|
|
|
|
let angleEpsilon: CGFloat = 30.0
|
|
var shouldHide = false
|
|
|
|
if (velocity.x * velocity.x + velocity.y * velocity.y) >= 500.0 * 500.0 {
|
|
let x = velocity.x
|
|
let y = velocity.y
|
|
|
|
var angle = atan2(y, x) * 180.0 / CGFloat.pi * -1.0
|
|
if angle < 0.0 {
|
|
angle += 360.0
|
|
}
|
|
|
|
if currentPosition.x.isZero && currentPosition.y.isZero {
|
|
if ((angle > 0 && angle < 90 - angleEpsilon) || angle > 360 - angleEpsilon) {
|
|
result.x = 1.0
|
|
result.y = 0.0
|
|
} else if (angle > 180 + angleEpsilon && angle < 270 + angleEpsilon) {
|
|
result.x = 0.0
|
|
result.y = 1.0
|
|
} else if (angle > 270 + angleEpsilon && angle < 360 - angleEpsilon) {
|
|
result.x = 1.0
|
|
result.y = 1.0
|
|
} else {
|
|
shouldHide = true
|
|
}
|
|
} else if !currentPosition.x.isZero && currentPosition.y.isZero {
|
|
if (angle > 90 + angleEpsilon && angle < 180 + angleEpsilon) {
|
|
result.x = 0.0
|
|
result.y = 0.0
|
|
}
|
|
else if (angle > 270 - angleEpsilon && angle < 360 - angleEpsilon) {
|
|
result.x = 1.0
|
|
result.y = 1.0
|
|
}
|
|
else if (angle > 180 + angleEpsilon && angle < 270 - angleEpsilon) {
|
|
result.x = 0.0
|
|
result.y = 1.0
|
|
}
|
|
else {
|
|
shouldHide = true
|
|
}
|
|
} else if currentPosition.x.isZero && !currentPosition.y.isZero {
|
|
if (angle > 90 - angleEpsilon && angle < 180 - angleEpsilon) {
|
|
result.x = 0.0
|
|
result.y = 0.0
|
|
}
|
|
else if (angle < angleEpsilon || angle > 270 + angleEpsilon) {
|
|
result.x = 1.0
|
|
result.y = 1.0
|
|
}
|
|
else if (angle > angleEpsilon && angle < 90 - angleEpsilon) {
|
|
result.x = 1.0
|
|
result.y = 0.0
|
|
}
|
|
else if (!shouldHide) {
|
|
shouldHide = true
|
|
}
|
|
} else if !currentPosition.x.isZero && !currentPosition.y.isZero {
|
|
if (angle > angleEpsilon && angle < 90 + angleEpsilon) {
|
|
result.x = 1.0
|
|
result.y = 0.0
|
|
}
|
|
else if (angle > 180 - angleEpsilon && angle < 270 - angleEpsilon) {
|
|
result.x = 0.0
|
|
result.y = 1.0
|
|
}
|
|
else if (angle > 90 + angleEpsilon && angle < 180 - angleEpsilon) {
|
|
result.x = 0.0
|
|
result.y = 0.0
|
|
}
|
|
else if (!shouldHide) {
|
|
shouldHide = true
|
|
}
|
|
}
|
|
}
|
|
|
|
if result.x.isZero {
|
|
if result.y.isZero {
|
|
return .topLeft
|
|
} else {
|
|
return .bottomLeft
|
|
}
|
|
} else {
|
|
if result.y.isZero {
|
|
return .topRight
|
|
} else {
|
|
return .bottomRight
|
|
}
|
|
}
|
|
}
|
|
|
|
@objc private func panGesture(_ recognizer: UIPanGestureRecognizer) {
|
|
switch recognizer.state {
|
|
case .began:
|
|
let location = recognizer.location(in: self.view)
|
|
//let translation = recognizer.translation(in: self.view)
|
|
//location.x += translation.x
|
|
//location.y += translation.y
|
|
if let _ = self.incomingVideoNode, let outgoingVideoNode = self.outgoingVideoNode, outgoingVideoNode.frame.contains(location) {
|
|
self.minimizedVideoInitialPosition = outgoingVideoNode.position
|
|
} else {
|
|
self.minimizedVideoInitialPosition = nil
|
|
}
|
|
case .changed:
|
|
if let outgoingVideoNode = self.outgoingVideoNode, let minimizedVideoInitialPosition = self.minimizedVideoInitialPosition {
|
|
let translation = recognizer.translation(in: self.view)
|
|
let minimizedVideoDraggingPosition = CGPoint(x: minimizedVideoInitialPosition.x + translation.x, y: minimizedVideoInitialPosition.y + translation.y)
|
|
self.minimizedVideoDraggingPosition = minimizedVideoDraggingPosition
|
|
outgoingVideoNode.position = minimizedVideoDraggingPosition
|
|
} else {
|
|
let offset = recognizer.translation(in: self.view).y
|
|
var bounds = self.bounds
|
|
bounds.origin.y = -offset
|
|
self.bounds = bounds
|
|
}
|
|
case .cancelled, .ended:
|
|
if let outgoingVideoNode = self.outgoingVideoNode, let _ = self.minimizedVideoInitialPosition, let minimizedVideoDraggingPosition = self.minimizedVideoDraggingPosition {
|
|
self.minimizedVideoInitialPosition = nil
|
|
self.minimizedVideoDraggingPosition = nil
|
|
|
|
if let (layout, navigationHeight) = self.validLayout {
|
|
self.outgoingVideoNodeCorner = self.nodeLocationForPosition(layout: layout, position: minimizedVideoDraggingPosition, velocity: recognizer.velocity(in: self.view))
|
|
|
|
let videoFrame = self.calculatePreviewVideoRect(layout: layout, navigationHeight: navigationHeight)
|
|
outgoingVideoNode.frame = videoFrame
|
|
outgoingVideoNode.layer.animateSpring(from: NSValue(cgPoint: CGPoint(x: minimizedVideoDraggingPosition.x - videoFrame.midX, y: minimizedVideoDraggingPosition.y - videoFrame.midY)), to: NSValue(cgPoint: CGPoint()), keyPath: "position", duration: 0.5, delay: 0.0, initialVelocity: 0.0, damping: 110.0, removeOnCompletion: true, additive: true, completion: nil)
|
|
}
|
|
} else {
|
|
let velocity = recognizer.velocity(in: self.view).y
|
|
if abs(velocity) < 100.0 {
|
|
var bounds = self.bounds
|
|
let previous = bounds
|
|
bounds.origin = CGPoint()
|
|
self.bounds = bounds
|
|
self.layer.animateBounds(from: previous, to: bounds, duration: 0.3, timingFunction: kCAMediaTimingFunctionSpring)
|
|
} else {
|
|
var bounds = self.bounds
|
|
let previous = bounds
|
|
bounds.origin = CGPoint(x: 0.0, y: velocity > 0.0 ? -bounds.height: bounds.height)
|
|
self.bounds = bounds
|
|
self.layer.animateBounds(from: previous, to: bounds, duration: 0.15, timingFunction: CAMediaTimingFunctionName.easeOut.rawValue, completion: { [weak self] _ in
|
|
self?.dismissedInteractively?()
|
|
})
|
|
}
|
|
}
|
|
default:
|
|
break
|
|
}
|
|
}
|
|
}
|