import Foundation
import UIKit
import Display
import AsyncDisplayKit
import SwiftSignalKit
import TelegramPresentationData
import TelegramUIPreferences
import TelegramStringFormatting
import TelegramVoip
import TelegramAudio
import AccountContext
import Postbox
import TelegramCore
import MergeLists
import ItemListUI
import AppBundle
import ContextUI
import ShareController
import DeleteChatPeerActionSheetItem
import UndoUI
import AlertUI
import PresentationDataUtils
import DirectionalPanGesture
import PeerInfoUI
import AvatarNode
import TooltipUI
import LegacyUI
import LegacyComponents
import LegacyMediaPickerUI
import WebSearchUI
import MapResourceToAvatarSizes
import SolidRoundedButtonNode
import AudioBlob
import DeviceAccess
let panelBackgroundColor = UIColor(rgb: 0x1c1c1e)
let secondaryPanelBackgroundColor = UIColor(rgb: 0x2c2c2e)
let fullscreenBackgroundColor = UIColor(rgb: 0x000000)
let smallButtonSize = CGSize(width: 36.0, height: 36.0)
let sideButtonSize = CGSize(width: 56.0, height: 56.0)
let topPanelHeight: CGFloat = 63.0
let bottomAreaHeight: CGFloat = 206.0
let fullscreenBottomAreaHeight: CGFloat = 80.0
let bottomGradientHeight: CGFloat = 70.0
func decorationCornersImage(top: Bool, bottom: Bool, dark: Bool) -> UIImage? {
if !top && !bottom {
return nil
}
return generateImage(CGSize(width: 50.0, height: 50.0), rotatedContext: { (size, context) in
let bounds = CGRect(origin: CGPoint(), size: size)
context.setFillColor((dark ? fullscreenBackgroundColor : panelBackgroundColor).cgColor)
context.fill(bounds)
context.setBlendMode(.clear)
var corners: UIRectCorner = []
if top {
corners.insert(.topLeft)
corners.insert(.topRight)
}
if bottom {
corners.insert(.bottomLeft)
corners.insert(.bottomRight)
}
let path = UIBezierPath(roundedRect: bounds, byRoundingCorners: corners, cornerRadii: CGSize(width: 11.0, height: 11.0))
context.addPath(path.cgPath)
context.fillPath()
})?.stretchableImage(withLeftCapWidth: 25, topCapHeight: 25)
}
func decorationTopCornersImage(dark: Bool) -> UIImage? {
return generateImage(CGSize(width: 50.0, height: 110.0), rotatedContext: { (size, context) in
let bounds = CGRect(origin: CGPoint(), size: size)
context.setFillColor((dark ? fullscreenBackgroundColor : panelBackgroundColor).cgColor)
context.fill(bounds)
context.setBlendMode(.clear)
var corners: UIRectCorner = []
corners.insert(.topLeft)
corners.insert(.topRight)
let path = UIBezierPath(roundedRect: CGRect(x: 0.0, y: 60.0, width: 50.0, height: 50.0), byRoundingCorners: corners, cornerRadii: CGSize(width: 11.0, height: 11.0))
context.addPath(path.cgPath)
context.fillPath()
})?.stretchableImage(withLeftCapWidth: 25, topCapHeight: 32)
}
func decorationBottomCornersImage(dark: Bool) -> UIImage? {
return generateImage(CGSize(width: 50.0, height: 110.0), rotatedContext: { (size, context) in
let bounds = CGRect(origin: CGPoint(), size: size)
context.setFillColor((dark ? fullscreenBackgroundColor : panelBackgroundColor).cgColor)
context.fill(bounds)
context.setBlendMode(.clear)
var corners: UIRectCorner = []
corners.insert(.bottomLeft)
corners.insert(.bottomRight)
let path = UIBezierPath(roundedRect: CGRect(x: 0.0, y: 0.0, width: 50.0, height: 50.0), byRoundingCorners: corners, cornerRadii: CGSize(width: 11.0, height: 11.0))
context.addPath(path.cgPath)
context.fillPath()
})?.resizableImage(withCapInsets: UIEdgeInsets(top: 25.0, left: 25.0, bottom: 0.0, right: 25.0), resizingMode: .stretch)
}
private func decorationBottomGradientImage(dark: Bool) -> UIImage? {
return generateImage(CGSize(width: 24.0, height: bottomGradientHeight), rotatedContext: { size, context in
let bounds = CGRect(origin: CGPoint(), size: size)
context.clear(bounds)
let color = dark ? fullscreenBackgroundColor : panelBackgroundColor
let colorsArray = [color.withAlphaComponent(0.0).cgColor, color.cgColor] as CFArray
var locations: [CGFloat] = [1.0, 0.0]
let gradient = CGGradient(colorsSpace: deviceColorSpace, colors: colorsArray, locations: &locations)!
context.drawLinearGradient(gradient, start: CGPoint(), end: CGPoint(x: 0.0, y: size.height), options: CGGradientDrawingOptions())
})
}
struct VoiceChatPeerEntry: Identifiable {
enum State {
case listening
case speaking
case invited
case raisedHand
}
var peer: Peer
var about: String?
var isMyPeer: Bool
var videoEndpointId: String?
var videoPaused: Bool
var presentationEndpointId: String?
var presentationPaused: Bool
var effectiveSpeakerVideoEndpointId: String?
var state: State
var muteState: GroupCallParticipantsContext.Participant.MuteState?
var canManageCall: Bool
var volume: Int32?
var raisedHand: Bool
var displayRaisedHandStatus: Bool
var active: Bool
var isLandscape: Bool
var effectiveVideoEndpointId: String? {
return self.presentationEndpointId ?? self.videoEndpointId
}
init(
peer: Peer,
about: String?,
isMyPeer: Bool,
videoEndpointId: String?,
videoPaused: Bool,
presentationEndpointId: String?,
presentationPaused: Bool,
effectiveSpeakerVideoEndpointId: String?,
state: State,
muteState: GroupCallParticipantsContext.Participant.MuteState?,
canManageCall: Bool,
volume: Int32?,
raisedHand: Bool,
displayRaisedHandStatus: Bool,
active: Bool,
isLandscape: Bool
) {
self.peer = peer
self.about = about
self.isMyPeer = isMyPeer
self.videoEndpointId = videoEndpointId
self.videoPaused = videoPaused
self.presentationEndpointId = presentationEndpointId
self.presentationPaused = presentationPaused
self.effectiveSpeakerVideoEndpointId = effectiveSpeakerVideoEndpointId
self.state = state
self.muteState = muteState
self.canManageCall = canManageCall
self.volume = volume
self.raisedHand = raisedHand
self.displayRaisedHandStatus = displayRaisedHandStatus
self.active = active
self.isLandscape = isLandscape
}
var stableId: PeerId {
return self.peer.id
}
static func ==(lhs: VoiceChatPeerEntry, rhs: VoiceChatPeerEntry) -> Bool {
if !lhs.peer.isEqual(rhs.peer) {
return false
}
if lhs.about != rhs.about {
return false
}
if lhs.isMyPeer != rhs.isMyPeer {
return false
}
if lhs.videoEndpointId != rhs.videoEndpointId {
return false
}
if lhs.videoPaused != rhs.videoPaused {
return false
}
if lhs.presentationEndpointId != rhs.presentationEndpointId {
return false
}
if lhs.presentationPaused != rhs.presentationPaused {
return false
}
if lhs.effectiveSpeakerVideoEndpointId != rhs.effectiveSpeakerVideoEndpointId {
return false
}
if lhs.state != rhs.state {
return false
}
if lhs.muteState != rhs.muteState {
return false
}
if lhs.canManageCall != rhs.canManageCall {
return false
}
if lhs.volume != rhs.volume {
return false
}
if lhs.raisedHand != rhs.raisedHand {
return false
}
if lhs.displayRaisedHandStatus != rhs.displayRaisedHandStatus {
return false
}
if lhs.active != rhs.active {
return false
}
if lhs.isLandscape != rhs.isLandscape {
return false
}
return true
}
}
public protocol VoiceChatController: ViewController {
var call: PresentationGroupCall { get }
var currentOverlayController: VoiceChatOverlayController? { get }
var parentNavigationController: NavigationController? { get set }
func dismiss(closing: Bool, manual: Bool)
}
public final class VoiceChatControllerImpl: ViewController, VoiceChatController {
enum DisplayMode {
case modal(isExpanded: Bool, isFilled: Bool)
case fullscreen(controlsHidden: Bool)
}
fileprivate final class Node: ViewControllerTracingNode, ASGestureRecognizerDelegate {
private struct ListTransition {
let deletions: [ListViewDeleteItem]
let insertions: [ListViewInsertItem]
let updates: [ListViewUpdateItem]
let isLoading: Bool
let isEmpty: Bool
let canInvite: Bool
let crossFade: Bool
let count: Int
let animated: Bool
}
private final class Interaction {
let updateIsMuted: (PeerId, Bool) -> Void
let switchToPeer: (PeerId, String?, Bool) -> Void
let openInvite: () -> Void
let peerContextAction: (VoiceChatPeerEntry, ASDisplayNode, ContextGesture?, Bool) -> Void
let getPeerVideo: (String, GroupVideoNode.Position) -> GroupVideoNode?
var isExpanded: Bool = false
private var audioLevels: [PeerId: ValuePipe<Float>] = [:]
var updateAvatarPromise = Promise<(TelegramMediaImageRepresentation, Float)?>(nil)
init(
updateIsMuted: @escaping (PeerId, Bool) -> Void,
switchToPeer: @escaping (PeerId, String?, Bool) -> Void,
openInvite: @escaping () -> Void,
peerContextAction: @escaping (VoiceChatPeerEntry, ASDisplayNode, ContextGesture?, Bool) -> Void,
getPeerVideo: @escaping (String, GroupVideoNode.Position) -> GroupVideoNode?
) {
self.updateIsMuted = updateIsMuted
self.switchToPeer = switchToPeer
self.openInvite = openInvite
self.peerContextAction = peerContextAction
self.getPeerVideo = getPeerVideo
}
func getAudioLevel(_ peerId: PeerId) -> Signal<Float, NoError> {
let signal: Signal<Float, NoError>
if let current = self.audioLevels[peerId] {
signal = current.signal()
} else {
let value = ValuePipe<Float>()
self.audioLevels[peerId] = value
signal = value.signal()
}
return signal
|> mapToSignal { value in
return .single(value)
}
}
func updateAudioLevels(_ levels: [(PeerId, UInt32, Float, Bool)], reset: Bool = false) {
var updated = Set<PeerId>()
for (peerId, _, level, _) in levels {
if let pipe = self.audioLevels[peerId] {
if reset {
pipe.putNext(level)
} else {
pipe.putNext(max(0.001, level))
}
updated.insert(peerId)
}
}
if !reset {
for (peerId, pipe) in self.audioLevels {
if !updated.contains(peerId) {
pipe.putNext(0.0)
}
}
}
}
}
private enum EntryId: Hashable {
case tiles
case invite
case peerId(PeerId)
static func <(lhs: EntryId, rhs: EntryId) -> Bool {
return lhs.hashValue < rhs.hashValue
}
static func ==(lhs: EntryId, rhs: EntryId) -> Bool {
switch lhs {
case .tiles:
switch rhs {
case .tiles:
return true
default:
return false
}
case .invite:
switch rhs {
case .invite:
return true
default:
return false
}
case let .peerId(lhsId):
switch rhs {
case let .peerId(rhsId):
return lhsId == rhsId
default:
return false
}
}
}
}
private enum ListEntry: Comparable, Identifiable {
case tiles([VoiceChatTileItem], VoiceChatTileLayoutMode, Int32, Bool)
case invite(PresentationTheme, PresentationStrings, String, Bool)
case peer(VoiceChatPeerEntry, Int32)
var stableId: EntryId {
switch self {
case .tiles:
return .tiles
case .invite:
return .invite
case let .peer(peerEntry, _):
return .peerId(peerEntry.peer.id)
}
}
static func ==(lhs: ListEntry, rhs: ListEntry) -> Bool {
switch lhs {
case let .tiles(lhsTiles, lhsLayoutMode, lhsVideoLimit, lhsReachedLimit):
if case let .tiles(rhsTiles, rhsLayoutMode, rhsVideoLimit, rhsReachedLimit) = rhs, lhsTiles == rhsTiles, lhsLayoutMode == rhsLayoutMode, lhsVideoLimit == rhsVideoLimit, lhsReachedLimit == rhsReachedLimit {
return true
} else {
return false
}
case let .invite(lhsTheme, lhsStrings, lhsText, lhsIsLink):
if case let .invite(rhsTheme, rhsStrings, rhsText, rhsIsLink) = rhs, lhsTheme === rhsTheme, lhsStrings === rhsStrings, lhsText == rhsText, lhsIsLink == rhsIsLink {
return true
} else {
return false
}
case let .peer(lhsPeerEntry, lhsIndex):
switch rhs {
case let .peer(rhsPeerEntry, rhsIndex):
return lhsPeerEntry == rhsPeerEntry && lhsIndex == rhsIndex
default:
return false
}
}
}
static func <(lhs: ListEntry, rhs: ListEntry) -> Bool {
switch lhs {
case .tiles:
return true
case .invite:
return false
case let .peer(_, lhsIndex):
switch rhs {
case .tiles:
return false
case let .peer(_, rhsIndex):
return lhsIndex < rhsIndex
case .invite:
return true
}
}
}
func tileItem(context: AccountContext, presentationData: PresentationData, interaction: Interaction, isTablet: Bool, videoEndpointId: String, videoReady: Bool, videoTimeouted: Bool, videoIsPaused: Bool, showAsPresentation: Bool, secondary: Bool) -> VoiceChatTileItem? {
guard case let .peer(peerEntry, _) = self else {
return nil
}
let peer = peerEntry.peer
let icon: VoiceChatTileItem.Icon
var text: VoiceChatParticipantItem.ParticipantText
var additionalText: VoiceChatParticipantItem.ParticipantText?
var speaking = false
var textIcon = VoiceChatParticipantItem.ParticipantText.TextIcon()
let yourText: String
if (peerEntry.about?.isEmpty ?? true) && peer.smallProfileImage == nil {
yourText = presentationData.strings.VoiceChat_TapToAddPhotoOrBio
} else if peer.smallProfileImage == nil {
yourText = presentationData.strings.VoiceChat_TapToAddPhoto
} else if (peerEntry.about?.isEmpty ?? true) {
yourText = presentationData.strings.VoiceChat_TapToAddBio
} else {
yourText = presentationData.strings.VoiceChat_You
}
var state = peerEntry.state
if let muteState = peerEntry.muteState, case .speaking = state, muteState.mutedByYou || !muteState.canUnmute {
state = .listening
}
switch state {
case .listening:
if peerEntry.isMyPeer {
text = .text(yourText, textIcon, .accent)
} else if let muteState = peerEntry.muteState, muteState.mutedByYou {
text = .text(presentationData.strings.VoiceChat_StatusMutedForYou, textIcon, .destructive)
} else if let about = peerEntry.about, !about.isEmpty {
text = .text(about, textIcon, .generic)
} else {
text = .text(presentationData.strings.VoiceChat_StatusListening, textIcon, .generic)
}
if let muteState = peerEntry.muteState, muteState.mutedByYou {
icon = .microphone(true)
additionalText = .text(presentationData.strings.VoiceChat_StatusMutedForYou, textIcon, .destructive)
} else {
icon = .microphone(peerEntry.muteState != nil)
}
case .speaking:
if let muteState = peerEntry.muteState, muteState.mutedByYou {
text = .text(presentationData.strings.VoiceChat_StatusMutedForYou, textIcon, .destructive)
icon = .microphone(true)
additionalText = .text(presentationData.strings.VoiceChat_StatusMutedForYou, textIcon, .destructive)
} else {
if peerEntry.volume != nil {
textIcon.insert(.volume)
}
let volumeValue = peerEntry.volume.flatMap { $0 / 100 }
if let volume = volumeValue, volume != 100 {
text = .text( presentationData.strings.VoiceChat_StatusSpeakingVolume("\(volume)%").string, textIcon, .constructive)
} else {
text = .text(presentationData.strings.VoiceChat_StatusSpeaking, textIcon, .constructive)
}
icon = .microphone(false)
speaking = true
}
case .raisedHand, .invited:
text = .none
icon = .none
}
if let about = peerEntry.about, !about.isEmpty {
textIcon = []
text = .text(about, textIcon, .generic)
}
return VoiceChatTileItem(account: context.account, peer: EnginePeer(peerEntry.peer), videoEndpointId: videoEndpointId, videoReady: videoReady, videoTimeouted: videoTimeouted, isVideoLimit: false, videoLimit: 0, isPaused: videoIsPaused, isOwnScreencast: peerEntry.presentationEndpointId == videoEndpointId && peerEntry.isMyPeer, strings: presentationData.strings, nameDisplayOrder: presentationData.nameDisplayOrder, speaking: speaking, secondary: secondary, isTablet: isTablet, icon: showAsPresentation ? .presentation : icon, text: text, additionalText: additionalText, action: {
interaction.switchToPeer(peer.id, videoEndpointId, !secondary)
}, contextAction: { node, gesture in
interaction.peerContextAction(peerEntry, node, gesture, false)
}, getVideo: { position in
return interaction.getPeerVideo(videoEndpointId, position)
}, getAudioLevel: {
return interaction.getAudioLevel(peerEntry.peer.id)
})
}
func fullscreenItem(context: AccountContext, presentationData: PresentationData, interaction: Interaction) -> ListViewItem {
switch self {
case .tiles:
return VoiceChatActionItem(presentationData: ItemListPresentationData(presentationData), title: "", icon: .none, action: {
})
case .invite:
return VoiceChatActionItem(presentationData: ItemListPresentationData(presentationData), title: "", icon: .generic(UIImage(bundleImageName: "Chat/Context Menu/AddUser")!), action: {
interaction.openInvite()
})
case let .peer(peerEntry, _):
let peer = peerEntry.peer
var textColor: VoiceChatFullscreenParticipantItem.Color = .generic
var color: VoiceChatFullscreenParticipantItem.Color = .generic
let icon: VoiceChatFullscreenParticipantItem.Icon
var text: VoiceChatParticipantItem.ParticipantText
var textIcon = VoiceChatParticipantItem.ParticipantText.TextIcon()
let yourText: String
if (peerEntry.about?.isEmpty ?? true) && peer.smallProfileImage == nil {
yourText = presentationData.strings.VoiceChat_TapToAddPhotoOrBio
} else if peer.smallProfileImage == nil {
yourText = presentationData.strings.VoiceChat_TapToAddPhoto
} else if (peerEntry.about?.isEmpty ?? true) {
yourText = presentationData.strings.VoiceChat_TapToAddBio
} else {
yourText = presentationData.strings.VoiceChat_You
}
var state = peerEntry.state
if let muteState = peerEntry.muteState, case .speaking = state, muteState.mutedByYou || !muteState.canUnmute {
state = .listening
}
switch state {
case .listening:
if peerEntry.isMyPeer {
text = .text(yourText, textIcon, .accent)
} else if let muteState = peerEntry.muteState, muteState.mutedByYou {
text = .text(presentationData.strings.VoiceChat_StatusMutedForYou, textIcon, .destructive)
} else if let about = peerEntry.about, !about.isEmpty {
text = .text(about, textIcon, .generic)
} else {
text = .text(presentationData.strings.VoiceChat_StatusListening, textIcon, .generic)
}
if let muteState = peerEntry.muteState, muteState.mutedByYou {
textColor = .destructive
color = .destructive
icon = .microphone(true, UIColor(rgb: 0xff3b30))
} else {
icon = .microphone(peerEntry.muteState != nil, UIColor.white)
color = .accent
}
case .speaking:
if let muteState = peerEntry.muteState, muteState.mutedByYou {
text = .text(presentationData.strings.VoiceChat_StatusMutedForYou, textIcon, .destructive)
textColor = .destructive
color = .destructive
icon = .microphone(true, UIColor(rgb: 0xff3b30))
} else {
if peerEntry.volume != nil {
textIcon.insert(.volume)
}
let volumeValue = peerEntry.volume.flatMap { $0 / 100 }
if let volume = volumeValue, volume != 100 {
text = .text( presentationData.strings.VoiceChat_StatusSpeakingVolume("\(volume)%").string, textIcon, .constructive)
} else {
text = .text(presentationData.strings.VoiceChat_StatusSpeaking, textIcon, .constructive)
}
icon = .microphone(false, UIColor(rgb: 0x34c759))
textColor = .constructive
color = .constructive
}
case .raisedHand:
text = .none
textColor = .accent
icon = .wantsToSpeak
case .invited:
text = .none
icon = .none
}
if let about = peerEntry.about, !about.isEmpty {
textIcon = []
text = .text(about, textIcon, .generic)
}
var videoEndpointId = peerEntry.effectiveVideoEndpointId
var otherVideoEndpointId: String?
let hasBothVideos = peerEntry.presentationEndpointId != nil && peerEntry.videoEndpointId != nil
if hasBothVideos {
if let effectiveVideoEndpointId = peerEntry.effectiveSpeakerVideoEndpointId {
if effectiveVideoEndpointId == peerEntry.videoEndpointId {
videoEndpointId = peerEntry.presentationEndpointId
otherVideoEndpointId = videoEndpointId
} else if effectiveVideoEndpointId == peerEntry.presentationEndpointId {
videoEndpointId = peerEntry.videoEndpointId
otherVideoEndpointId = videoEndpointId
}
}
}
var isPaused = false
if videoEndpointId == peerEntry.videoEndpointId {
isPaused = peerEntry.videoPaused
} else if videoEndpointId == peerEntry.presentationEndpointId {
isPaused = peerEntry.presentationPaused
}
return VoiceChatFullscreenParticipantItem(presentationData: ItemListPresentationData(presentationData), nameDisplayOrder: presentationData.nameDisplayOrder, context: context, peer: peerEntry.peer, videoEndpointId: videoEndpointId, isPaused: isPaused, icon: icon, text: text, textColor: textColor, color: color, isLandscape: peerEntry.isLandscape, active: peerEntry.active, showVideoWhenActive: otherVideoEndpointId != nil, getAudioLevel: { return interaction.getAudioLevel(peerEntry.peer.id) }, getVideo: {
if let videoEndpointId = videoEndpointId {
return interaction.getPeerVideo(videoEndpointId, .list)
} else {
return nil
}
}, action: { _ in
interaction.switchToPeer(peerEntry.peer.id, otherVideoEndpointId, false)
}, contextAction: { node, gesture in
interaction.peerContextAction(peerEntry, node, gesture, true)
}, getUpdatingAvatar: {
return interaction.updateAvatarPromise.get()
})
}
}
func item(context: AccountContext, presentationData: PresentationData, interaction: Interaction) -> ListViewItem {
switch self {
case let .tiles(tiles, layoutMode, videoLimit, reachedLimit):
return VoiceChatTilesGridItem(context: context, tiles: tiles, layoutMode: layoutMode, videoLimit: videoLimit, reachedLimit: reachedLimit, getIsExpanded: {
return interaction.isExpanded
})
case let .invite(_, _, text, isLink):
return VoiceChatActionItem(presentationData: ItemListPresentationData(presentationData), title: text, icon: .generic(UIImage(bundleImageName: isLink ? "Chat/Context Menu/Link" : "Chat/Context Menu/AddUser")!), action: {
interaction.openInvite()
})
case let .peer(peerEntry, _):
let peer = peerEntry.peer
var text: VoiceChatParticipantItem.ParticipantText
var expandedText: VoiceChatParticipantItem.ParticipantText?
let icon: VoiceChatParticipantItem.Icon
var state = peerEntry.state
if let muteState = peerEntry.muteState, case .speaking = state, muteState.mutedByYou || !muteState.canUnmute {
state = .listening
}
var textIcon = VoiceChatParticipantItem.ParticipantText.TextIcon()
let yourText: String
if (peerEntry.about?.isEmpty ?? true) && peer.smallProfileImage == nil {
yourText = presentationData.strings.VoiceChat_TapToAddPhotoOrBio
} else if peer.smallProfileImage == nil {
yourText = presentationData.strings.VoiceChat_TapToAddPhoto
} else if (peerEntry.about?.isEmpty ?? true) {
yourText = presentationData.strings.VoiceChat_TapToAddBio
} else {
yourText = presentationData.strings.VoiceChat_You
}
switch state {
case .listening:
if peerEntry.isMyPeer {
text = .text(yourText, textIcon, .accent)
} else if let muteState = peerEntry.muteState, muteState.mutedByYou {
text = .text(presentationData.strings.VoiceChat_StatusMutedForYou, textIcon, .destructive)
} else if let about = peerEntry.about, !about.isEmpty {
text = .text(about, textIcon, .generic)
} else {
text = .text(presentationData.strings.VoiceChat_StatusListening, textIcon, .generic)
}
let microphoneColor: UIColor
if let muteState = peerEntry.muteState, !muteState.canUnmute || muteState.mutedByYou {
microphoneColor = UIColor(rgb: 0xff3b30)
} else {
microphoneColor = UIColor(rgb: 0x979797)
}
icon = .microphone(peerEntry.muteState != nil, microphoneColor)
case .speaking:
if let muteState = peerEntry.muteState, muteState.mutedByYou {
text = .text(presentationData.strings.VoiceChat_StatusMutedForYou, textIcon, .destructive)
icon = .microphone(true, UIColor(rgb: 0xff3b30))
} else {
if peerEntry.volume != nil {
textIcon.insert(.volume)
}
let volumeValue = peerEntry.volume.flatMap { $0 / 100 }
if let volume = volumeValue, volume != 100 {
text = .text( presentationData.strings.VoiceChat_StatusSpeakingVolume("\(volume)%").string, textIcon, .constructive)
} else {
text = .text(presentationData.strings.VoiceChat_StatusSpeaking, textIcon, .constructive)
}
icon = .microphone(false, UIColor(rgb: 0x34c759))
}
case .invited:
text = .text(presentationData.strings.VoiceChat_StatusInvited, textIcon, .generic)
icon = .invite(true)
case .raisedHand:
if peerEntry.isMyPeer && !peerEntry.displayRaisedHandStatus {
text = .text(yourText, textIcon, .accent)
} else if let about = peerEntry.about, !about.isEmpty && !peerEntry.displayRaisedHandStatus {
text = .text(about, textIcon, .generic)
} else {
text = .text(presentationData.strings.VoiceChat_StatusWantsToSpeak, textIcon, .accent)
}
icon = .wantsToSpeak
}
if let about = peerEntry.about, !about.isEmpty {
textIcon = []
expandedText = .text(about, textIcon, .generic)
}
return VoiceChatParticipantItem(presentationData: ItemListPresentationData(presentationData), dateTimeFormat: presentationData.dateTimeFormat, nameDisplayOrder: presentationData.nameDisplayOrder, context: context, peer: EnginePeer(peer), text: text, expandedText: expandedText, icon: icon, getAudioLevel: { return interaction.getAudioLevel(peer.id) }, action: { node in
if let node = node {
interaction.peerContextAction(peerEntry, node, nil, false)
}
}, contextAction: { node, gesture in
interaction.peerContextAction(peerEntry, node, gesture, false)
}, getIsExpanded: {
return interaction.isExpanded
}, getUpdatingAvatar: {
return interaction.updateAvatarPromise.get()
})
}
}
}
private func preparedTransition(from fromEntries: [ListEntry], to toEntries: [ListEntry], isLoading: Bool, isEmpty: Bool, canInvite: Bool, crossFade: Bool, animated: Bool, context: AccountContext, presentationData: PresentationData, interaction: Interaction) -> ListTransition {
let (deleteIndices, indicesAndItems, updateIndices) = mergeListsStableWithUpdates(leftList: fromEntries, rightList: toEntries)
let deletions = deleteIndices.map { ListViewDeleteItem(index: $0, directionHint: nil) }
let insertions = indicesAndItems.map { ListViewInsertItem(index: $0.0, previousIndex: $0.2, item: $0.1.item(context: context, presentationData: presentationData, interaction: interaction), directionHint: nil) }
let updates = updateIndices.map { ListViewUpdateItem(index: $0.0, previousIndex: $0.2, item: $0.1.item(context: context, presentationData: presentationData, interaction: interaction), directionHint: nil) }
return ListTransition(deletions: deletions, insertions: insertions, updates: updates, isLoading: isLoading, isEmpty: isEmpty, canInvite: canInvite, crossFade: crossFade, count: toEntries.count, animated: animated)
}
private func preparedFullscreenTransition(from fromEntries: [ListEntry], to toEntries: [ListEntry], isLoading: Bool, isEmpty: Bool, canInvite: Bool, crossFade: Bool, animated: Bool, context: AccountContext, presentationData: PresentationData, interaction: Interaction) -> ListTransition {
let (deleteIndices, indicesAndItems, updateIndices) = mergeListsStableWithUpdates(leftList: fromEntries, rightList: toEntries)
let deletions = deleteIndices.map { ListViewDeleteItem(index: $0, directionHint: nil) }
let insertions = indicesAndItems.map { ListViewInsertItem(index: $0.0, previousIndex: $0.2, item: $0.1.fullscreenItem(context: context, presentationData: presentationData, interaction: interaction), directionHint: nil) }
let updates = updateIndices.map { ListViewUpdateItem(index: $0.0, previousIndex: $0.2, item: $0.1.fullscreenItem(context: context, presentationData: presentationData, interaction: interaction), directionHint: nil) }
return ListTransition(deletions: deletions, insertions: insertions, updates: updates, isLoading: isLoading, isEmpty: isEmpty, canInvite: canInvite, crossFade: crossFade, count: toEntries.count, animated: animated)
}
private let currentAvatarMixin = Atomic<TGMediaAvatarMenuMixin?>(value: nil)
private var configuration: VoiceChatConfiguration?
private weak var controller: VoiceChatControllerImpl?
private let sharedContext: SharedAccountContext
private let context: AccountContext
private let call: PresentationGroupCall
private var presentationData: PresentationData
private var presentationDataDisposable: Disposable?
private var darkTheme: PresentationTheme
private let dimNode: ASDisplayNode
private let contentContainer: ASDisplayNode
private let backgroundNode: ASDisplayNode
private let listContainer: ASDisplayNode
private let listNode: ListView
private let fullscreenListContainer: ASDisplayNode
private let fullscreenListNode: ListView
private let tileGridNode: VoiceChatTileGridNode
private let topPanelNode: ASDisplayNode
private let topPanelEdgeNode: ASDisplayNode
private let topPanelBackgroundNode: ASDisplayNode
private let optionsButton: VoiceChatHeaderButton
private let closeButton: VoiceChatHeaderButton
private let panelButton: VoiceChatHeaderButton
private let topCornersNode: ASImageNode
fileprivate let bottomPanelNode: ASDisplayNode
private let bottomGradientNode: ASDisplayNode
private let bottomPanelBackgroundNode: ASDisplayNode
private let bottomCornersNode: ASImageNode
fileprivate let audioButton: CallControllerButtonItemNode
fileprivate let cameraButton: CallControllerButtonItemNode
fileprivate let switchCameraButton: CallControllerButtonItemNode
fileprivate let leaveButton: CallControllerButtonItemNode
fileprivate let actionButton: VoiceChatActionButton
private let leftBorderNode: ASDisplayNode
private let rightBorderNode: ASDisplayNode
private let mainStageContainerNode: ASDisplayNode
private let mainStageBackgroundNode: ASDisplayNode
private let mainStageNode: VoiceChatMainStageNode
private let transitionMaskView: UIView
private let transitionMaskTopFillLayer: CALayer
private let transitionMaskFillLayer: CALayer
private let transitionMaskGradientLayer: CAGradientLayer
private let transitionMaskBottomFillLayer: CALayer
private let transitionContainerNode: ASDisplayNode
private var isScheduling = false
private let timerNode: VoiceChatTimerNode
private var pickerView: UIDatePicker?
private let dateFormatter: DateFormatter
private let scheduleTextNode: ImmediateTextNode
private let scheduleCancelButton: SolidRoundedButtonNode
private var scheduleButtonTitle = ""
private let titleNode: VoiceChatTitleNode
private let participantsNode: VoiceChatTimerNode
private var enqueuedTransitions: [ListTransition] = []
private var enqueuedFullscreenTransitions: [ListTransition] = []
private var validLayout: (ContainerViewLayout, CGFloat)?
private var didSetContentsReady: Bool = false
private var didSetDataReady: Bool = false
private var isFirstTime = true
private var topInset: CGFloat?
private var animatingInsertion = false
private var animatingExpansion = false
private var animatingAppearance = false
private var animatingButtonsSwap = false
private var animatingMainStage = false
private var animatingContextMenu = false
private var panGestureArguments: (topInset: CGFloat, offset: CGFloat)?
private var isPanning = false
private var peer: Peer?
private var currentTitle: String = ""
private var currentTitleIsCustom = false
private var currentSubtitle: String = ""
private var currentSpeakingSubtitle: String?
private var currentCallMembers: ([GroupCallParticipantsContext.Participant], String?)?
private var currentTotalCount: Int32 = 0
private var currentInvitedPeers: [EnginePeer]?
private var currentSpeakingPeers: Set<PeerId>?
private var currentContentOffset: CGFloat?
private var currentNormalButtonColor: UIColor?
private var currentActiveButtonColor: UIColor?
private var myEntry: VoiceChatPeerEntry?
private var mainEntry: VoiceChatPeerEntry?
private var currentEntries: [ListEntry] = []
private var currentFullscreenEntries: [ListEntry] = []
private var currentTileItems: [VoiceChatTileItem] = []
private var displayPanelVideos = false
private var joinedVideo: Bool?
private var peerViewDisposable: Disposable?
private let leaveDisposable = MetaDisposable()
private var isMutedDisposable: Disposable?
private var isNoiseSuppressionEnabled: Bool = true
private var isNoiseSuppressionEnabledDisposable: Disposable?
private var callStateDisposable: Disposable?
private var pushingToTalk = false
private var temporaryPushingToTalk = false
private let hapticFeedback = HapticFeedback()
private var callState: PresentationGroupCallState?
private var currentLoadToken: String?
private var scrollAtTop = true
private var effectiveMuteState: GroupCallParticipantsContext.Participant.MuteState? {
if self.pushingToTalk {
return nil
} else {
return self.callState?.muteState
}
}
private var audioOutputStateDisposable: Disposable?
private var audioOutputState: ([AudioSessionOutput], AudioSessionOutput?)?
private var audioLevelsDisposable: Disposable?
private var myAudioLevelDisposable: Disposable?
private var isSpeakingDisposable: Disposable?
private var memberStatesDisposable: Disposable?
private var actionButtonColorDisposable: Disposable?
private var itemInteraction: Interaction?
private let inviteDisposable = MetaDisposable()
private let memberEventsDisposable = MetaDisposable()
private let reconnectedAsEventsDisposable = MetaDisposable()
private let stateVersionDisposable = MetaDisposable()
private var applicationStateDisposable: Disposable?
private let displayAsPeersPromise = Promise<[FoundPeer]>([])
private let inviteLinksPromise = Promise<GroupCallInviteLinks?>(nil)
private var raisedHandDisplayDisposables: [PeerId: Disposable] = [:]
private var displayedRaisedHands = Set<PeerId>() {
didSet {
self.displayedRaisedHandsPromise.set(self.displayedRaisedHands)
}
}
private let displayedRaisedHandsPromise = ValuePromise<Set<PeerId>>(Set())
private var requestedVideoSources = Set<String>()
private var requestedVideoChannels: [PresentationGroupCallRequestedVideo] = []
private var videoRenderingContext: VideoRenderingContext
private var videoNodes: [String: GroupVideoNode] = [:]
private var wideVideoNodes = Set<String>()
private var videoOrder: [String] = []
private var readyVideoEndpointIds = Set<String>()
private var readyVideoEndpointIdsPromise = ValuePromise<Set<String>>(Set())
private var timeoutedEndpointIds = Set<String>()
private var readyVideoDisposables = DisposableDict<String>()
private var myPeerVideoReadyDisposable = MetaDisposable()
private var peerIdToEndpointId: [PeerId: String] = [:]
private var currentSpeakers: [PeerId] = []
private var currentDominantSpeaker: (PeerId, String?, Double)?
private var currentForcedSpeaker: (PeerId, String?)?
private var effectiveSpeaker: (PeerId, String?, Bool, Bool, Bool)?
private var updateAvatarDisposable = MetaDisposable()
private let updateAvatarPromise = Promise<(TelegramMediaImageRepresentation, Float)?>(nil)
private var currentUpdatingAvatar: TelegramMediaImageRepresentation?
private var connectedOnce = false
private var ignoreConnecting = false
private var ignoreConnectingTimer: SwiftSignalKit.Timer?
private var displayUnmuteTooltipTimer: SwiftSignalKit.Timer?
private var dismissUnmuteTooltipTimer: SwiftSignalKit.Timer?
private var lastUnmuteTooltipDisplayTimestamp: Double?
private var panelHidden = false
private var displayMode: DisplayMode = .modal(isExpanded: false, isFilled: false) {
didSet {
if case let .modal(isExpanded, _) = self.displayMode {
self.itemInteraction?.isExpanded = isExpanded
} else {
self.itemInteraction?.isExpanded = true
}
}
}
private var isExpanded: Bool {
switch self.displayMode {
case .modal(true, _), .fullscreen:
return true
default:
return false
}
}
private var statsDisposable: Disposable?
init(controller: VoiceChatControllerImpl, sharedContext: SharedAccountContext, call: PresentationGroupCall) {
self.controller = controller
self.sharedContext = sharedContext
self.context = call.accountContext
self.call = call
self.videoRenderingContext = VideoRenderingContext()
self.isScheduling = call.schedulePending
let presentationData = sharedContext.currentPresentationData.with { $0 }
self.presentationData = presentationData
self.darkTheme = defaultDarkColorPresentationTheme
self.currentSubtitle = self.presentationData.strings.SocksProxySetup_ProxyStatusConnecting
self.dimNode = ASDisplayNode()
self.dimNode.backgroundColor = UIColor(white: 0.0, alpha: 0.5)
self.contentContainer = ASDisplayNode()
self.contentContainer.isHidden = true
self.backgroundNode = ASDisplayNode()
self.backgroundNode.backgroundColor = self.isScheduling ? panelBackgroundColor : secondaryPanelBackgroundColor
self.backgroundNode.clipsToBounds = false
self.listContainer = ASDisplayNode()
self.listNode = ListView()
self.listNode.alpha = self.isScheduling ? 0.0 : 1.0
self.listNode.isUserInteractionEnabled = !self.isScheduling
self.listNode.verticalScrollIndicatorColor = UIColor(white: 1.0, alpha: 0.3)
self.listNode.clipsToBounds = true
self.listNode.scroller.bounces = false
self.listNode.accessibilityPageScrolledString = { row, count in
return presentationData.strings.VoiceOver_ScrollStatus(row, count).string
}
self.fullscreenListContainer = ASDisplayNode()
self.fullscreenListContainer.isHidden = true
self.fullscreenListNode = ListView()
self.fullscreenListNode.transform = CATransform3DMakeRotation(-CGFloat(CGFloat.pi / 2.0), 0.0, 0.0, 1.0)
self.fullscreenListNode.clipsToBounds = true
self.fullscreenListNode.accessibilityPageScrolledString = { row, count in
return presentationData.strings.VoiceOver_ScrollStatus(row, count).string
}
self.tileGridNode = VoiceChatTileGridNode(context: self.context)
self.topPanelNode = ASDisplayNode()
self.topPanelNode.clipsToBounds = false
self.topPanelBackgroundNode = ASDisplayNode()
self.topPanelBackgroundNode.backgroundColor = panelBackgroundColor
self.topPanelBackgroundNode.isUserInteractionEnabled = false
self.topPanelEdgeNode = ASDisplayNode()
self.topPanelEdgeNode.backgroundColor = panelBackgroundColor
self.topPanelEdgeNode.cornerRadius = 12.0
self.topPanelEdgeNode.isUserInteractionEnabled = false
if #available(iOS 11.0, *) {
self.topPanelEdgeNode.layer.maskedCorners = [.layerMinXMinYCorner, .layerMaxXMinYCorner]
}
self.optionsButton = VoiceChatHeaderButton(context: self.context)
self.optionsButton.setContent(.more(optionsCircleImage(dark: false)))
self.closeButton = VoiceChatHeaderButton(context: self.context)
self.closeButton.setContent(.image(closeButtonImage(dark: false)))
self.panelButton = VoiceChatHeaderButton(context: self.context, wide: true)
self.panelButton.setContent(.image(panelButtonImage(dark: false)))
self.titleNode = VoiceChatTitleNode(theme: self.presentationData.theme)
self.topCornersNode = ASImageNode()
self.topCornersNode.displaysAsynchronously = false
self.topCornersNode.displayWithoutProcessing = true
self.topCornersNode.image = decorationTopCornersImage(dark: false)
self.topCornersNode.isUserInteractionEnabled = false
self.bottomPanelNode = ASDisplayNode()
self.bottomPanelNode.clipsToBounds = false
self.bottomPanelBackgroundNode = ASDisplayNode()
self.bottomPanelBackgroundNode.backgroundColor = panelBackgroundColor
self.bottomPanelBackgroundNode.isUserInteractionEnabled = false
self.bottomGradientNode = ASDisplayNode()
self.bottomGradientNode.displaysAsynchronously = false
self.bottomGradientNode.backgroundColor = decorationBottomGradientImage(dark: false).flatMap { UIColor(patternImage: $0) }
self.bottomCornersNode = ASImageNode()
self.bottomCornersNode.displaysAsynchronously = false
self.bottomCornersNode.displayWithoutProcessing = true
self.bottomCornersNode.image = decorationBottomCornersImage(dark: false)
self.bottomCornersNode.isUserInteractionEnabled = false
self.audioButton = CallControllerButtonItemNode()
self.cameraButton = CallControllerButtonItemNode(largeButtonSize: sideButtonSize.width)
self.switchCameraButton = CallControllerButtonItemNode()
self.switchCameraButton.alpha = 0.0
self.switchCameraButton.isUserInteractionEnabled = false
self.leaveButton = CallControllerButtonItemNode()
self.actionButton = VoiceChatActionButton()
self.actionButton.animationsEnabled = sharedContext.energyUsageSettings.fullTranslucency
if self.isScheduling {
self.cameraButton.alpha = 0.0
self.cameraButton.isUserInteractionEnabled = false
self.audioButton.alpha = 0.0
self.audioButton.isUserInteractionEnabled = false
self.leaveButton.alpha = 0.0
self.leaveButton.isUserInteractionEnabled = false
}
self.leftBorderNode = ASDisplayNode()
self.leftBorderNode.backgroundColor = panelBackgroundColor
self.leftBorderNode.isUserInteractionEnabled = false
self.leftBorderNode.clipsToBounds = false
self.rightBorderNode = ASDisplayNode()
self.rightBorderNode.backgroundColor = panelBackgroundColor
self.rightBorderNode.isUserInteractionEnabled = false
self.rightBorderNode.clipsToBounds = false
self.mainStageContainerNode = ASDisplayNode()
self.mainStageContainerNode.clipsToBounds = true
self.mainStageContainerNode.isUserInteractionEnabled = false
self.mainStageContainerNode.isHidden = true
self.mainStageBackgroundNode = ASDisplayNode()
self.mainStageBackgroundNode.backgroundColor = .black
self.mainStageBackgroundNode.alpha = 0.0
self.mainStageBackgroundNode.isUserInteractionEnabled = false
self.mainStageNode = VoiceChatMainStageNode(context: self.context, call: self.call)
self.transitionMaskView = UIView()
self.transitionMaskTopFillLayer = CALayer()
self.transitionMaskTopFillLayer.backgroundColor = UIColor.white.cgColor
self.transitionMaskTopFillLayer.opacity = 0.0
self.transitionMaskFillLayer = CALayer()
self.transitionMaskFillLayer.backgroundColor = UIColor.white.cgColor
self.transitionMaskGradientLayer = CAGradientLayer()
self.transitionMaskGradientLayer.colors = [UIColor.white.cgColor, UIColor.white.withAlphaComponent(0.0).cgColor]
self.transitionMaskGradientLayer.locations = [0.0, 1.0]
self.transitionMaskGradientLayer.startPoint = CGPoint(x: 0.0, y: 0.0)
self.transitionMaskGradientLayer.endPoint = CGPoint(x: 0.0, y: 1.0)
self.transitionMaskBottomFillLayer = CALayer()
self.transitionMaskBottomFillLayer.backgroundColor = UIColor.white.cgColor
self.transitionMaskBottomFillLayer.opacity = 0.0
self.transitionMaskView.layer.addSublayer(self.transitionMaskTopFillLayer)
self.transitionMaskView.layer.addSublayer(self.transitionMaskFillLayer)
self.transitionMaskView.layer.addSublayer(self.transitionMaskGradientLayer)
self.transitionMaskView.layer.addSublayer(self.transitionMaskBottomFillLayer)
self.transitionContainerNode = ASDisplayNode()
self.transitionContainerNode.clipsToBounds = true
self.transitionContainerNode.isUserInteractionEnabled = false
self.transitionContainerNode.view.mask = self.transitionMaskView
// self.transitionContainerNode.view.addSubview(self.transitionMaskView)
self.scheduleTextNode = ImmediateTextNode()
self.scheduleTextNode.isHidden = !self.isScheduling
self.scheduleTextNode.isUserInteractionEnabled = false
self.scheduleTextNode.textAlignment = .center
self.scheduleTextNode.maximumNumberOfLines = 4
self.scheduleCancelButton = SolidRoundedButtonNode(title: self.presentationData.strings.Common_Cancel, theme: SolidRoundedButtonTheme(backgroundColor: UIColor(rgb: 0x2b2b2f), foregroundColor: .white), height: 52.0, cornerRadius: 10.0)
self.scheduleCancelButton.isHidden = !self.isScheduling
self.dateFormatter = DateFormatter()
self.dateFormatter.timeStyle = .none
self.dateFormatter.dateStyle = .short
self.dateFormatter.timeZone = TimeZone.current
self.timerNode = VoiceChatTimerNode(strings: self.presentationData.strings, dateTimeFormat: self.presentationData.dateTimeFormat)
self.timerNode.isHidden = true
self.participantsNode = VoiceChatTimerNode(strings: self.presentationData.strings, dateTimeFormat: self.presentationData.dateTimeFormat)
super.init()
let context = self.context
let currentAccountPeer = self.context.account.postbox.loadedPeerWithId(context.account.peerId)
|> map { peer in
return [FoundPeer(peer: peer, subscribers: nil)]
}
self.isNoiseSuppressionEnabledDisposable = (call.isNoiseSuppressionEnabled
|> deliverOnMainQueue).start(next: { [weak self] value in
guard let strongSelf = self else {
return
}
strongSelf.isNoiseSuppressionEnabled = value
})
let displayAsPeers: Signal<[FoundPeer], NoError> = currentAccountPeer
|> then(
combineLatest(currentAccountPeer, context.engine.calls.cachedGroupCallDisplayAsAvailablePeers(peerId: call.peerId))
|> map { currentAccountPeer, availablePeers -> [FoundPeer] in
var result = currentAccountPeer
result.append(contentsOf: availablePeers)
return result
}
)
self.displayAsPeersPromise.set(displayAsPeers)
self.inviteLinksPromise.set(.single(nil)
|> then(call.inviteLinks))
self.itemInteraction = Interaction(updateIsMuted: { [weak self] peerId, isMuted in
let _ = self?.call.updateMuteState(peerId: peerId, isMuted: isMuted)
}, switchToPeer: { [weak self] peerId, videoEndpointId, expand in
if let strongSelf = self, strongSelf.connectedOnce {
if expand, let videoEndpointId = videoEndpointId {
strongSelf.currentDominantSpeaker = (peerId, videoEndpointId, CACurrentMediaTime() + 3.0)
strongSelf.updateDisplayMode(.fullscreen(controlsHidden: false))
} else {
strongSelf.currentForcedSpeaker = nil
if peerId != strongSelf.currentDominantSpeaker?.0 || (videoEndpointId != nil && videoEndpointId != strongSelf.currentDominantSpeaker?.1) {
strongSelf.currentDominantSpeaker = (peerId, videoEndpointId, CACurrentMediaTime())
}
strongSelf.updateMainVideo(waitForFullSize: true, updateMembers: true, force: true)
}
}
}, openInvite: { [weak self] in
guard let strongSelf = self else {
return
}
let groupPeer = strongSelf.context.engine.data.get(TelegramEngine.EngineData.Item.Peer.Peer(id: strongSelf.call.peerId))
let _ = combineLatest(queue: Queue.mainQueue(), groupPeer, strongSelf.inviteLinksPromise.get() |> take(1)).start(next: { groupPeer, inviteLinks in
guard let strongSelf = self else {
return
}
guard let groupPeer = groupPeer else {
return
}
if case let .channel(groupPeer) = groupPeer {
var canInviteMembers = true
if case .broadcast = groupPeer.info, !(groupPeer.addressName?.isEmpty ?? true) {
canInviteMembers = false
}
if !canInviteMembers {
if let inviteLinks = inviteLinks {
strongSelf.presentShare(inviteLinks)
}
return
}
}
var filters: [ChannelMembersSearchFilter] = []
if let (currentCallMembers, _) = strongSelf.currentCallMembers {
filters.append(.disable(Array(currentCallMembers.map { $0.peer.id })))
}
if case let .channel(groupPeer) = groupPeer {
if !groupPeer.hasPermission(.inviteMembers) && inviteLinks?.listenerLink == nil {
filters.append(.excludeNonMembers)
}
} else if case let .legacyGroup(groupPeer) = groupPeer {
if groupPeer.hasBannedPermission(.banAddMembers) {
filters.append(.excludeNonMembers)
}
}
filters.append(.excludeBots)
var dismissController: (() -> Void)?
let controller = ChannelMembersSearchController(context: strongSelf.context, peerId: groupPeer.id, forceTheme: strongSelf.darkTheme, mode: .inviteToCall, filters: filters, openPeer: { peer, participant in
guard let strongSelf = self else {
dismissController?()
return
}
let presentationData = strongSelf.context.sharedContext.currentPresentationData.with { $0 }
if peer.id == strongSelf.callState?.myPeerId {
return
}
if let participant = participant {
dismissController?()
if strongSelf.call.invitePeer(participant.peer.id) {
let text: String
if let channel = strongSelf.peer as? TelegramChannel, case .broadcast = channel.info {
text = strongSelf.presentationData.strings.LiveStream_InvitedPeerText(peer.displayTitle(strings: strongSelf.presentationData.strings, displayOrder: strongSelf.presentationData.nameDisplayOrder)).string
} else {
text = strongSelf.presentationData.strings.VoiceChat_InvitedPeerText(peer.displayTitle(strings: strongSelf.presentationData.strings, displayOrder: strongSelf.presentationData.nameDisplayOrder)).string
}
strongSelf.presentUndoOverlay(content: .invitedToVoiceChat(context: strongSelf.context, peer: EnginePeer(participant.peer), text: text, action: nil, duration: 3), action: { _ in return false })
}
} else {
if case let .channel(groupPeer) = groupPeer, let listenerLink = inviteLinks?.listenerLink, !groupPeer.hasPermission(.inviteMembers) {
let text = strongSelf.presentationData.strings.VoiceChat_SendPublicLinkText(peer.displayTitle(strings: strongSelf.presentationData.strings, displayOrder: strongSelf.presentationData.nameDisplayOrder), EnginePeer(groupPeer).displayTitle(strings: strongSelf.presentationData.strings, displayOrder: strongSelf.presentationData.nameDisplayOrder)).string
strongSelf.controller?.present(textAlertController(context: strongSelf.context, forceTheme: strongSelf.darkTheme, title: nil, text: text, actions: [TextAlertAction(type: .genericAction, title: presentationData.strings.Common_Cancel, action: {}), TextAlertAction(type: .defaultAction, title: presentationData.strings.VoiceChat_SendPublicLinkSend, action: { [weak self] in
dismissController?()
if let strongSelf = self {
let _ = (enqueueMessages(account: strongSelf.context.account, peerId: peer.id, messages: [.message(text: listenerLink, attributes: [], inlineStickers: [:], mediaReference: nil, threadId: nil, replyToMessageId: nil, replyToStoryId: nil, localGroupingKey: nil, correlationId: nil, bubbleUpEmojiOrStickersets: [])])
|> deliverOnMainQueue).start(next: { [weak self] _ in
if let strongSelf = self {
strongSelf.presentUndoOverlay(content: .forward(savedMessages: false, text: strongSelf.presentationData.strings.UserInfo_LinkForwardTooltip_Chat_One(peer.displayTitle(strings: strongSelf.presentationData.strings, displayOrder: strongSelf.presentationData.nameDisplayOrder)).string), action: { _ in return true })
}
})
}
})]), in: .window(.root))
} else {
let text: String
if case let .channel(groupPeer) = groupPeer, case .broadcast = groupPeer.info {
text = strongSelf.presentationData.strings.VoiceChat_InviteMemberToChannelFirstText(peer.displayTitle(strings: strongSelf.presentationData.strings, displayOrder: strongSelf.presentationData.nameDisplayOrder), EnginePeer(groupPeer).displayTitle(strings: strongSelf.presentationData.strings, displayOrder: strongSelf.presentationData.nameDisplayOrder)).string
} else {
text = strongSelf.presentationData.strings.VoiceChat_InviteMemberToGroupFirstText(peer.displayTitle(strings: strongSelf.presentationData.strings, displayOrder: strongSelf.presentationData.nameDisplayOrder), groupPeer.displayTitle(strings: strongSelf.presentationData.strings, displayOrder: strongSelf.presentationData.nameDisplayOrder)).string
}
strongSelf.controller?.present(textAlertController(context: strongSelf.context, forceTheme: strongSelf.darkTheme, title: nil, text: text, actions: [TextAlertAction(type: .genericAction, title: presentationData.strings.Common_Cancel, action: {}), TextAlertAction(type: .defaultAction, title: presentationData.strings.VoiceChat_InviteMemberToGroupFirstAdd, action: {
guard let strongSelf = self else {
return
}
if case let .channel(groupPeer) = groupPeer {
let selfController = strongSelf.controller
let inviteDisposable = strongSelf.inviteDisposable
var inviteSignal = strongSelf.context.peerChannelMemberCategoriesContextsManager.addMembers(engine: strongSelf.context.engine, peerId: groupPeer.id, memberIds: [peer.id])
var cancelImpl: (() -> Void)?
let progressSignal = Signal<Never, NoError> { [weak selfController] subscriber in
let controller = OverlayStatusController(theme: presentationData.theme, type: .loading(cancelled: {
cancelImpl?()
}))
selfController?.present(controller, in: .window(.root))
return ActionDisposable { [weak controller] in
Queue.mainQueue().async() {
controller?.dismiss()
}
}
}
|> runOn(Queue.mainQueue())
|> delay(0.15, queue: Queue.mainQueue())
let progressDisposable = progressSignal.start()
inviteSignal = inviteSignal
|> afterDisposed {
Queue.mainQueue().async {
progressDisposable.dispose()
}
}
cancelImpl = {
inviteDisposable.set(nil)
}
inviteDisposable.set((inviteSignal |> deliverOnMainQueue).start(error: { error in
dismissController?()
guard let strongSelf = self else {
return
}
let presentationData = strongSelf.context.sharedContext.currentPresentationData.with { $0 }
let text: String
switch error {
case .limitExceeded:
text = presentationData.strings.Channel_ErrorAddTooMuch
case .tooMuchJoined:
text = presentationData.strings.Invite_ChannelsTooMuch
case .generic:
text = presentationData.strings.Login_UnknownError
case .restricted:
text = presentationData.strings.Channel_ErrorAddBlocked
case .notMutualContact:
if case .broadcast = groupPeer.info {
text = presentationData.strings.Channel_AddUserLeftError
} else {
text = presentationData.strings.GroupInfo_AddUserLeftError
}
case .botDoesntSupportGroups:
text = presentationData.strings.Channel_BotDoesntSupportGroups
case .tooMuchBots:
text = presentationData.strings.Channel_TooMuchBots
case .bot:
text = presentationData.strings.Login_UnknownError
case .kicked:
text = presentationData.strings.Channel_AddUserKickedError
}
strongSelf.controller?.present(textAlertController(context: strongSelf.context, forceTheme: strongSelf.darkTheme, title: nil, text: text, actions: [TextAlertAction(type: .defaultAction, title: presentationData.strings.Common_OK, action: {})]), in: .window(.root))
}, completed: {
guard let strongSelf = self else {
dismissController?()
return
}
dismissController?()
if strongSelf.call.invitePeer(peer.id) {
let text: String
if let channel = strongSelf.peer as? TelegramChannel, case .broadcast = channel.info {
text = strongSelf.presentationData.strings.LiveStream_InvitedPeerText(peer.displayTitle(strings: strongSelf.presentationData.strings, displayOrder: strongSelf.presentationData.nameDisplayOrder)).string
} else {
text = strongSelf.presentationData.strings.VoiceChat_InvitedPeerText(peer.displayTitle(strings: strongSelf.presentationData.strings, displayOrder: strongSelf.presentationData.nameDisplayOrder)).string
}
strongSelf.presentUndoOverlay(content: .invitedToVoiceChat(context: strongSelf.context, peer: peer, text: text, action: nil, duration: 3), action: { _ in return false })
}
}))
} else if case let .legacyGroup(groupPeer) = groupPeer {
let selfController = strongSelf.controller
let inviteDisposable = strongSelf.inviteDisposable
var inviteSignal = strongSelf.context.engine.peers.addGroupMember(peerId: groupPeer.id, memberId: peer.id)
var cancelImpl: (() -> Void)?
let progressSignal = Signal<Never, NoError> { [weak selfController] subscriber in
let controller = OverlayStatusController(theme: presentationData.theme, type: .loading(cancelled: {
cancelImpl?()
}))
selfController?.present(controller, in: .window(.root))
return ActionDisposable { [weak controller] in
Queue.mainQueue().async() {
controller?.dismiss()
}
}
}
|> runOn(Queue.mainQueue())
|> delay(0.15, queue: Queue.mainQueue())
let progressDisposable = progressSignal.start()
inviteSignal = inviteSignal
|> afterDisposed {
Queue.mainQueue().async {
progressDisposable.dispose()
}
}
cancelImpl = {
inviteDisposable.set(nil)
}
inviteDisposable.set((inviteSignal |> deliverOnMainQueue).start(error: { error in
dismissController?()
guard let strongSelf = self else {
return
}
let context = strongSelf.context
let presentationData = strongSelf.context.sharedContext.currentPresentationData.with { $0 }
switch error {
case .privacy:
let _ = (strongSelf.context.account.postbox.loadedPeerWithId(peer.id)
|> deliverOnMainQueue).start(next: { peer in
self?.controller?.present(textAlertController(context: context, title: nil, text: presentationData.strings.Privacy_GroupsAndChannels_InviteToGroupError(EnginePeer(peer).compactDisplayTitle, EnginePeer(peer).compactDisplayTitle).string, actions: [TextAlertAction(type: .genericAction, title: presentationData.strings.Common_OK, action: {})]), in: .window(.root))
})
case .notMutualContact:
strongSelf.controller?.present(textAlertController(context: context, title: nil, text: presentationData.strings.GroupInfo_AddUserLeftError, actions: [TextAlertAction(type: .genericAction, title: presentationData.strings.Common_OK, action: {})]), in: .window(.root))
case .tooManyChannels:
strongSelf.controller?.present(textAlertController(context: context, title: nil, text: presentationData.strings.Invite_ChannelsTooMuch, actions: [TextAlertAction(type: .genericAction, title: presentationData.strings.Common_OK, action: {})]), in: .window(.root))
case .groupFull, .generic:
strongSelf.controller?.present(textAlertController(context: strongSelf.context, forceTheme: strongSelf.darkTheme, title: nil, text: presentationData.strings.Login_UnknownError, actions: [TextAlertAction(type: .defaultAction, title: presentationData.strings.Common_OK, action: {})]), in: .window(.root))
}
}, completed: {
guard let strongSelf = self else {
dismissController?()
return
}
dismissController?()
if strongSelf.call.invitePeer(peer.id) {
let text: String
if let channel = strongSelf.peer as? TelegramChannel, case .broadcast = channel.info {
text = strongSelf.presentationData.strings.LiveStream_InvitedPeerText(peer.displayTitle(strings: strongSelf.presentationData.strings, displayOrder: strongSelf.presentationData.nameDisplayOrder)).string
} else {
text = strongSelf.presentationData.strings.VoiceChat_InvitedPeerText(peer.displayTitle(strings: strongSelf.presentationData.strings, displayOrder: strongSelf.presentationData.nameDisplayOrder)).string
}
strongSelf.presentUndoOverlay(content: .invitedToVoiceChat(context: strongSelf.context, peer: peer, text: text, action: nil, duration: 3), action: { _ in return false })
}
}))
}
})]), in: .window(.root))
}
}
})
controller.copyInviteLink = {
dismissController?()
guard let strongSelf = self else {
return
}
let callPeerId = strongSelf.call.peerId
let _ = (strongSelf.context.engine.data.get(
TelegramEngine.EngineData.Item.Peer.Peer(id: callPeerId),
TelegramEngine.EngineData.Item.Peer.ExportedInvitation(id: callPeerId)
)
|> map { peer, exportedInvitation -> String? in
if let link = inviteLinks?.listenerLink {
return link
} else if let peer = peer, let addressName = peer.addressName, !addressName.isEmpty {
return "https://t.me/\(addressName)"
} else if let link = exportedInvitation?.link {
return link
} else {
return nil
}
}
|> deliverOnMainQueue).start(next: { link in
guard let strongSelf = self else {
return
}
if let link = link {
UIPasteboard.general.string = link
strongSelf.presentUndoOverlay(content: .linkCopied(text: strongSelf.presentationData.strings.VoiceChat_InviteLinkCopiedText), action: { _ in return false })
}
})
}
dismissController = { [weak controller] in
controller?.dismiss()
}
strongSelf.controller?.push(controller)
})
}, peerContextAction: { [weak self] entry, sourceNode, gesture, fullscreen in
guard let strongSelf = self, let sourceNode = sourceNode as? ContextExtractedContentContainingNode else {
return
}
let muteStatePromise = Promise<GroupCallParticipantsContext.Participant.MuteState?>(entry.muteState)
let itemsForEntry: (VoiceChatPeerEntry, GroupCallParticipantsContext.Participant.MuteState?) -> [ContextMenuItem] = { entry, muteState in
var items: [ContextMenuItem] = []
var hasVolumeSlider = false
let peer = entry.peer
if let muteState = muteState, !muteState.canUnmute || muteState.mutedByYou {
} else {
if entry.canManageCall || !entry.isMyPeer {
hasVolumeSlider = true
let minValue: CGFloat
if let callState = strongSelf.callState, callState.canManageCall && callState.adminIds.contains(peer.id) && muteState != nil {
minValue = 0.01
} else {
minValue = 0.0
}
items.append(.custom(VoiceChatVolumeContextItem(minValue: minValue, value: entry.volume.flatMap { CGFloat($0) / 10000.0 } ?? 1.0, valueChanged: { newValue, finished in
if finished && newValue.isZero {
let updatedMuteState = strongSelf.call.updateMuteState(peerId: peer.id, isMuted: true)
muteStatePromise.set(.single(updatedMuteState))
} else {
strongSelf.call.setVolume(peerId: peer.id, volume: Int32(newValue * 10000), sync: finished)
}
}), true))
}
}
if entry.isMyPeer && !hasVolumeSlider && ((entry.about?.isEmpty ?? true) || entry.peer.smallProfileImage == nil) {
items.append(.custom(VoiceChatInfoContextItem(text: strongSelf.presentationData.strings.VoiceChat_ImproveYourProfileText, icon: { theme in
return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Tip"), color: theme.actionSheet.primaryTextColor)
}), true))
}
if peer.id == strongSelf.callState?.myPeerId {
if entry.raisedHand {
items.append(.action(ContextMenuActionItem(text: strongSelf.presentationData.strings.VoiceChat_CancelSpeakRequest, icon: { theme in
return generateTintedImage(image: UIImage(bundleImageName: "Call/Context Menu/RevokeSpeak"), color: theme.actionSheet.primaryTextColor)
}, action: { _, f in
guard let strongSelf = self else {
return
}
let _ = strongSelf.call.lowerHand()
f(.default)
})))
}
items.append(.action(ContextMenuActionItem(text: peer.smallProfileImage == nil ? strongSelf.presentationData.strings.VoiceChat_AddPhoto : strongSelf.presentationData.strings.VoiceChat_ChangePhoto, icon: { theme in
return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Camera"), color: theme.actionSheet.primaryTextColor)
}, action: { _, f in
guard let strongSelf = self else {
return
}
f(.default)
Queue.mainQueue().after(0.1) {
strongSelf.openAvatarForEditing(fromGallery: false, completion: {})
}
})))
items.append(.action(ContextMenuActionItem(text: (entry.about?.isEmpty ?? true) ? strongSelf.presentationData.strings.VoiceChat_AddBio : strongSelf.presentationData.strings.VoiceChat_EditBio, icon: { theme in
return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Info"), color: theme.actionSheet.primaryTextColor)
}, action: { _, f in
guard let strongSelf = self else {
return
}
f(.default)
Queue.mainQueue().after(0.1) {
let maxBioLength: Int
if peer.id.namespace == Namespaces.Peer.CloudUser {
maxBioLength = 70
} else {
maxBioLength = 100
}
let controller = voiceChatTitleEditController(sharedContext: strongSelf.context.sharedContext, account: strongSelf.context.account, forceTheme: strongSelf.darkTheme, title: presentationData.strings.VoiceChat_EditBioTitle, text: presentationData.strings.VoiceChat_EditBioText, placeholder: presentationData.strings.VoiceChat_EditBioPlaceholder, doneButtonTitle: presentationData.strings.VoiceChat_EditBioSave, value: entry.about, maxLength: maxBioLength, apply: { bio in
if let strongSelf = self, let bio = bio {
if peer.id.namespace == Namespaces.Peer.CloudUser {
let _ = (strongSelf.context.engine.accountData.updateAbout(about: bio)
|> `catch` { _ -> Signal<Void, NoError> in
return .complete()
}).start()
} else {
let _ = (strongSelf.context.engine.peers.updatePeerDescription(peerId: peer.id, description: bio)
|> `catch` { _ -> Signal<Void, NoError> in
return .complete()
}).start()
}
strongSelf.presentUndoOverlay(content: .info(title: nil, text: strongSelf.presentationData.strings.VoiceChat_EditBioSuccess, timeout: nil, customUndoText: nil), action: { _ in return false })
}
})
self?.controller?.present(controller, in: .window(.root))
}
})))
if let peer = peer as? TelegramUser {
items.append(.action(ContextMenuActionItem(text: strongSelf.presentationData.strings.VoiceChat_ChangeName, icon: { theme in
return generateTintedImage(image: UIImage(bundleImageName: "Call/Context Menu/ChangeName"), color: theme.actionSheet.primaryTextColor)
}, action: { _, f in
guard let strongSelf = self else {
return
}
f(.default)
Queue.mainQueue().after(0.1) {
let controller = voiceChatUserNameController(sharedContext: strongSelf.context.sharedContext, account: strongSelf.context.account, forceTheme: strongSelf.darkTheme, title: presentationData.strings.VoiceChat_ChangeNameTitle, firstNamePlaceholder: presentationData.strings.UserInfo_FirstNamePlaceholder, lastNamePlaceholder: presentationData.strings.UserInfo_LastNamePlaceholder, doneButtonTitle: presentationData.strings.VoiceChat_EditBioSave, firstName: peer.firstName, lastName: peer.lastName, maxLength: 128, apply: { firstAndLastName in
if let strongSelf = self, let (firstName, lastName) = firstAndLastName {
let _ = context.engine.accountData.updateAccountPeerName(firstName: firstName, lastName: lastName).start()
strongSelf.presentUndoOverlay(content: .info(title: nil, text: strongSelf.presentationData.strings.VoiceChat_EditNameSuccess, timeout: nil, customUndoText: nil), action: { _ in return false })
}
})
self?.controller?.present(controller, in: .window(.root))
}
})))
}
} else {
if let callState = strongSelf.callState, (callState.canManageCall || callState.adminIds.contains(strongSelf.context.account.peerId)) {
if callState.adminIds.contains(peer.id) {
if let _ = muteState {
} else {
items.append(.action(ContextMenuActionItem(text: strongSelf.presentationData.strings.VoiceChat_MutePeer, icon: { theme in
return generateTintedImage(image: UIImage(bundleImageName: "Call/Context Menu/Mute"), color: theme.actionSheet.primaryTextColor)
}, action: { _, f in
guard let strongSelf = self else {
return
}
let _ = strongSelf.call.updateMuteState(peerId: peer.id, isMuted: true)
f(.default)
})))
}
} else {
if let muteState = muteState, !muteState.canUnmute {
items.append(.action(ContextMenuActionItem(text: strongSelf.presentationData.strings.VoiceChat_UnmutePeer, icon: { theme in
return generateTintedImage(image: UIImage(bundleImageName: entry.raisedHand ? "Call/Context Menu/AllowToSpeak" : "Call/Context Menu/Unmute"), color: theme.actionSheet.primaryTextColor)
}, action: { _, f in
guard let strongSelf = self else {
return
}
let _ = strongSelf.call.updateMuteState(peerId: peer.id, isMuted: false)
f(.default)
strongSelf.presentUndoOverlay(content: .voiceChatCanSpeak(text: presentationData.strings.VoiceChat_UserCanNowSpeak(EnginePeer(entry.peer).displayTitle(strings: strongSelf.presentationData.strings, displayOrder: strongSelf.presentationData.nameDisplayOrder)).string), action: { _ in return true })
})))
} else {
items.append(.action(ContextMenuActionItem(text: strongSelf.presentationData.strings.VoiceChat_MutePeer, icon: { theme in
return generateTintedImage(image: UIImage(bundleImageName: "Call/Context Menu/Mute"), color: theme.actionSheet.primaryTextColor)
}, action: { _, f in
guard let strongSelf = self else {
return
}
let _ = strongSelf.call.updateMuteState(peerId: peer.id, isMuted: true)
f(.default)
})))
}
}
} else {
if let muteState = muteState, muteState.mutedByYou {
items.append(.action(ContextMenuActionItem(text: strongSelf.presentationData.strings.VoiceChat_UnmuteForMe, icon: { theme in
return generateTintedImage(image: UIImage(bundleImageName: "Call/Context Menu/Unmute"), color: theme.actionSheet.primaryTextColor)
}, action: { _, f in
guard let strongSelf = self else {
return
}
let _ = strongSelf.call.updateMuteState(peerId: peer.id, isMuted: false)
f(.default)
})))
} else {
items.append(.action(ContextMenuActionItem(text: strongSelf.presentationData.strings.VoiceChat_MuteForMe, icon: { theme in
return generateTintedImage(image: UIImage(bundleImageName: "Call/Context Menu/Mute"), color: theme.actionSheet.primaryTextColor)
}, action: { _, f in
guard let strongSelf = self else {
return
}
let _ = strongSelf.call.updateMuteState(peerId: peer.id, isMuted: true)
f(.default)
})))
}
}
let openTitle: String
let openIcon: UIImage?
if [Namespaces.Peer.CloudChannel, Namespaces.Peer.CloudGroup].contains(peer.id.namespace) {
if let peer = peer as? TelegramChannel, case .broadcast = peer.info {
openTitle = strongSelf.presentationData.strings.VoiceChat_OpenChannel
openIcon = UIImage(bundleImageName: "Chat/Context Menu/Channels")
} else {
openTitle = strongSelf.presentationData.strings.VoiceChat_OpenGroup
openIcon = UIImage(bundleImageName: "Chat/Context Menu/Groups")
}
} else {
openTitle = strongSelf.presentationData.strings.Conversation_ContextMenuSendMessage
openIcon = UIImage(bundleImageName: "Chat/Context Menu/Message")
}
items.append(.action(ContextMenuActionItem(text: openTitle, icon: { theme in
return generateTintedImage(image: openIcon, color: theme.actionSheet.primaryTextColor)
}, action: { _, f in
guard let strongSelf = self, let navigationController = strongSelf.controller?.parentNavigationController else {
return
}
let context = strongSelf.context
strongSelf.controller?.dismiss(completion: {
Queue.mainQueue().after(0.3) {
context.sharedContext.navigateToChatController(NavigateToChatControllerParams(navigationController: navigationController, context: context, chatLocation: .peer(EnginePeer(peer)), keepStack: .always, purposefulAction: {}, peekData: nil))
}
})
f(.dismissWithoutContent)
})))
if let callState = strongSelf.callState, (callState.canManageCall && !callState.adminIds.contains(peer.id)), peer.id != strongSelf.call.peerId {
items.append(.action(ContextMenuActionItem(text: strongSelf.presentationData.strings.VoiceChat_RemovePeer, textColor: .destructive, icon: { theme in
return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Clear"), color: theme.actionSheet.destructiveActionTextColor)
}, action: { [weak self] c, _ in
c?.dismiss(completion: {
guard let strongSelf = self else {
return
}
let _ = (strongSelf.context.account.postbox.loadedPeerWithId(strongSelf.call.peerId)
|> deliverOnMainQueue).start(next: { [weak self] chatPeer in
guard let strongSelf = self else {
return
}
let actionSheet = ActionSheetController(presentationData: strongSelf.presentationData.withUpdated(theme: strongSelf.darkTheme))
var items: [ActionSheetItem] = []
items.append(DeleteChatPeerActionSheetItem(context: strongSelf.context, peer: EnginePeer(peer), chatPeer: EnginePeer(chatPeer), action: .removeFromGroup, strings: strongSelf.presentationData.strings, nameDisplayOrder: strongSelf.presentationData.nameDisplayOrder))
items.append(ActionSheetButtonItem(title: strongSelf.presentationData.strings.VoiceChat_RemovePeerRemove, color: .destructive, action: { [weak actionSheet] in
actionSheet?.dismissAnimated()
guard let strongSelf = self else {
return
}
let _ = strongSelf.context.peerChannelMemberCategoriesContextsManager.updateMemberBannedRights(engine: strongSelf.context.engine, peerId: strongSelf.call.peerId, memberId: peer.id, bannedRights: TelegramChatBannedRights(flags: [.banReadMessages], untilDate: Int32.max)).start()
strongSelf.call.removedPeer(peer.id)
strongSelf.presentUndoOverlay(content: .banned(text: strongSelf.presentationData.strings.VoiceChat_RemovedPeerText(EnginePeer(peer).displayTitle(strings: strongSelf.presentationData.strings, displayOrder: strongSelf.presentationData.nameDisplayOrder)).string), action: { _ in return false })
}))
actionSheet.setItemGroups([
ActionSheetItemGroup(items: items),
ActionSheetItemGroup(items: [
ActionSheetButtonItem(title: strongSelf.presentationData.strings.Common_Cancel, color: .accent, font: .bold, action: { [weak actionSheet] in
actionSheet?.dismissAnimated()
})
])
])
strongSelf.controller?.present(actionSheet, in: .window(.root))
})
})
})))
}
}
return items
}
let items = muteStatePromise.get()
|> map { muteState -> [ContextMenuItem] in
return itemsForEntry(entry, muteState)
}
var centerVertically = entry.peer.smallProfileImage != nil || (!fullscreen && entry.effectiveVideoEndpointId != nil)
if let (layout, _) = strongSelf.validLayout, case .regular = layout.metrics.widthClass {
centerVertically = false
}
var useMaskView = true
if case .fullscreen = strongSelf.displayMode {
useMaskView = false
}
let dismissPromise = ValuePromise<Bool>(false)
let source = VoiceChatContextExtractedContentSource(sourceNode: sourceNode, maskView: useMaskView ? strongSelf.transitionMaskView : nil, keepInPlace: false, blurBackground: true, centerVertically: centerVertically, shouldBeDismissed: dismissPromise.get(), animateTransitionIn: { [weak self] in
if let strongSelf = self {
strongSelf.animatingContextMenu = true
strongSelf.updateDecorationsLayout(transition: .immediate)
if strongSelf.isLandscape {
strongSelf.transitionMaskTopFillLayer.opacity = 1.0
}
strongSelf.transitionContainerNode.view.mask = nil
strongSelf.transitionMaskBottomFillLayer.animateAlpha(from: 0.0, to: 1.0, duration: 0.4, removeOnCompletion: false, completion: { [weak self] _ in
Queue.mainQueue().after(0.3) {
self?.transitionMaskTopFillLayer.opacity = 0.0
self?.transitionMaskBottomFillLayer.removeAllAnimations()
self?.animatingContextMenu = false
self?.updateDecorationsLayout(transition: .immediate)
}
})
}
}, animateTransitionOut: { [weak self] in
if let strongSelf = self {
strongSelf.animatingContextMenu = true
strongSelf.updateDecorationsLayout(transition: .immediate)
strongSelf.transitionMaskTopFillLayer.animateAlpha(from: 1.0, to: 0.0, duration: 0.4)
strongSelf.transitionMaskBottomFillLayer.animateAlpha(from: 1.0, to: 0.0, duration: 0.4, completion: { [weak self] _ in
self?.animatingContextMenu = false
self?.updateDecorationsLayout(transition: .immediate)
self?.transitionContainerNode.view.mask = self?.transitionMaskView
})
}
})
sourceNode.requestDismiss = {
dismissPromise.set(true)
}
let contextController = ContextController(presentationData: strongSelf.presentationData.withUpdated(theme: strongSelf.darkTheme), source: .extracted(source), items: items |> map { ContextController.Items(content: .list($0)) }, gesture: gesture)
contextController.useComplexItemsTransitionAnimation = true
strongSelf.controller?.presentInGlobalOverlay(contextController)
}, getPeerVideo: { [weak self] endpointId, position in
guard let strongSelf = self else {
return nil
}
var ignore = false
if case .mainstage = position {
ignore = false
} else if case .fullscreen = strongSelf.displayMode, !strongSelf.isPanning {
ignore = ![.mainstage, .list].contains(position)
} else {
ignore = position != .tile
}
if ignore {
return nil
}
if !strongSelf.readyVideoEndpointIds.contains(endpointId) {
return nil
}
for (listEndpointId, videoNode) in strongSelf.videoNodes {
if listEndpointId == endpointId {
if position != .mainstage && videoNode.isMainstageExclusive {
return nil
}
return videoNode
}
}
return nil
})
self.itemInteraction?.updateAvatarPromise = self.updateAvatarPromise
self.topPanelNode.addSubnode(self.topPanelEdgeNode)
self.topPanelNode.addSubnode(self.topPanelBackgroundNode)
self.topPanelNode.addSubnode(self.titleNode)
self.topPanelNode.addSubnode(self.optionsButton)
self.topPanelNode.addSubnode(self.closeButton)
self.topPanelNode.addSubnode(self.panelButton)
self.bottomPanelNode.addSubnode(self.cameraButton)
self.bottomPanelNode.addSubnode(self.audioButton)
self.bottomPanelNode.addSubnode(self.switchCameraButton)
self.bottomPanelNode.addSubnode(self.leaveButton)
self.bottomPanelNode.addSubnode(self.actionButton)
self.bottomPanelNode.addSubnode(self.scheduleCancelButton)
self.addSubnode(self.dimNode)
self.addSubnode(self.contentContainer)
self.contentContainer.addSubnode(self.backgroundNode)
self.contentContainer.addSubnode(self.listContainer)
self.contentContainer.addSubnode(self.topPanelNode)
self.listContainer.addSubnode(self.listNode)
self.listContainer.addSubnode(self.leftBorderNode)
self.listContainer.addSubnode(self.rightBorderNode)
self.listContainer.addSubnode(self.bottomCornersNode)
self.listContainer.addSubnode(self.topCornersNode)
self.contentContainer.addSubnode(self.bottomGradientNode)
self.contentContainer.addSubnode(self.bottomPanelBackgroundNode)
// self.contentContainer.addSubnode(self.participantsNode)
self.contentContainer.addSubnode(self.tileGridNode)
self.contentContainer.addSubnode(self.mainStageContainerNode)
self.contentContainer.addSubnode(self.transitionContainerNode)
self.contentContainer.addSubnode(self.bottomPanelNode)
self.contentContainer.addSubnode(self.timerNode)
self.contentContainer.addSubnode(self.scheduleTextNode)
self.contentContainer.addSubnode(self.fullscreenListContainer)
self.fullscreenListContainer.addSubnode(self.fullscreenListNode)
self.mainStageContainerNode.addSubnode(self.mainStageBackgroundNode)
self.mainStageContainerNode.addSubnode(self.mainStageNode)
self.updateDecorationsColors()
let invitedPeers: Signal<[EnginePeer], NoError> = self.call.invitedPeers
|> mapToSignal { ids -> Signal<[EnginePeer], NoError> in
return context.engine.data.get(EngineDataList(
ids.map(TelegramEngine.EngineData.Item.Peer.Peer.init)
))
|> map { itemList -> [EnginePeer] in
return itemList.compactMap { $0 }
}
}
self.presentationDataDisposable = (sharedContext.presentationData
|> deliverOnMainQueue).start(next: { [weak self] presentationData in
if let strongSelf = self {
strongSelf.presentationData = presentationData
let sourceColor = presentationData.theme.chatList.unreadBadgeInactiveBackgroundColor
let color: UIColor
if sourceColor.alpha < 1.0 {
color = presentationData.theme.chatList.unreadBadgeInactiveBackgroundColor.mixedWith(sourceColor.withAlphaComponent(1.0), alpha: sourceColor.alpha)
} else {
color = sourceColor
}
strongSelf.actionButton.connectingColor = color
}
})
self.memberStatesDisposable = (combineLatest(queue: .mainQueue(),
self.call.state,
self.call.members,
invitedPeers,
self.displayAsPeersPromise.get(),
self.context.account.postbox.preferencesView(keys: [PreferencesKeys.appConfiguration])
)
|> mapToThrottled { values in
return .single(values)
|> then(.complete() |> delay(0.1, queue: Queue.mainQueue()))
}).start(next: { [weak self] state, callMembers, invitedPeers, displayAsPeers, preferencesView in
guard let strongSelf = self else {
return
}
let appConfiguration: AppConfiguration = preferencesView.values[PreferencesKeys.appConfiguration]?.get(AppConfiguration.self) ?? .defaultValue
let configuration = VoiceChatConfiguration.with(appConfiguration: appConfiguration)
strongSelf.configuration = configuration
var animate = false
if strongSelf.callState != state {
if let previousCallState = strongSelf.callState {
var networkStateUpdated = false
if case .connecting = previousCallState.networkState, case .connected = state.networkState {
networkStateUpdated = true
strongSelf.connectedOnce = true
}
var canUnmuteUpdated = false
if previousCallState.muteState?.canUnmute != state.muteState?.canUnmute {
canUnmuteUpdated = true
}
if previousCallState.isVideoEnabled != state.isVideoEnabled || (state.isVideoEnabled && networkStateUpdated) || canUnmuteUpdated {
strongSelf.animatingButtonsSwap = true
animate = true
}
}
strongSelf.callState = state
strongSelf.mainStageNode.callState = state
if let muteState = state.muteState, !muteState.canUnmute {
if strongSelf.pushingToTalk {
strongSelf.pushingToTalk = false
strongSelf.actionButton.pressing = false
strongSelf.actionButton.isUserInteractionEnabled = false
strongSelf.actionButton.isUserInteractionEnabled = true
}
}
}
strongSelf.updateMembers(muteState: strongSelf.effectiveMuteState, callMembers: (callMembers?.participants ?? [], callMembers?.loadMoreToken), invitedPeers: invitedPeers, speakingPeers: callMembers?.speakingParticipants ?? [])
let totalCount = Int32(max(1, callMembers?.totalCount ?? 0))
strongSelf.currentTotalCount = totalCount
let subtitle = strongSelf.presentationData.strings.VoiceChat_Panel_Members(totalCount)
strongSelf.currentSubtitle = subtitle
if strongSelf.isScheduling {
strongSelf.optionsButton.isUserInteractionEnabled = false
strongSelf.optionsButton.alpha = 0.0
strongSelf.closeButton.isUserInteractionEnabled = false
strongSelf.closeButton.alpha = 0.0
strongSelf.panelButton.isUserInteractionEnabled = false
strongSelf.panelButton.alpha = 0.0
} else {
if let (layout, _) = strongSelf.validLayout {
if case .regular = layout.metrics.widthClass, !strongSelf.peerIdToEndpointId.isEmpty {
strongSelf.panelButton.isUserInteractionEnabled = true
} else {
strongSelf.panelButton.isUserInteractionEnabled = false
}
}
if let callState = strongSelf.callState, callState.canManageCall {
strongSelf.optionsButton.isUserInteractionEnabled = true
} else if displayAsPeers.count > 1 {
strongSelf.optionsButton.isUserInteractionEnabled = true
} else {
strongSelf.optionsButton.isUserInteractionEnabled = true
}
}
if let (layout, navigationHeight) = strongSelf.validLayout {
strongSelf.containerLayoutUpdated(layout, navigationHeight: navigationHeight, transition: animate ? .animated(duration: 0.4, curve: .spring) : .immediate)
}
})
let titleAndRecording: Signal<(String?, Bool), NoError> = self.call.state
|> map { state -> (String?, Bool) in
return (state.title, state.recordingStartTimestamp != nil)
}
self.peerViewDisposable = combineLatest(queue: Queue.mainQueue(), self.context.account.viewTracker.peerView(self.call.peerId), titleAndRecording).start(next: { [weak self] view, titleAndRecording in
guard let strongSelf = self else {
return
}
let (title, isRecording) = titleAndRecording
if let peer = peerViewMainPeer(view) {
let isLivestream: Bool
if let channel = peer as? TelegramChannel, case .broadcast = channel.info {
isLivestream = true
} else {
isLivestream = false
}
strongSelf.participantsNode.isHidden = !isLivestream || strongSelf.isScheduled
let hadPeer = strongSelf.peer != nil
strongSelf.peer = peer
strongSelf.currentTitleIsCustom = title != nil
strongSelf.currentTitle = title ?? EnginePeer(peer).displayTitle(strings: strongSelf.presentationData.strings, displayOrder: strongSelf.presentationData.nameDisplayOrder)
strongSelf.updateTitle(transition: .immediate)
strongSelf.titleNode.isRecording = isRecording
if strongSelf.isScheduling && !hadPeer {
strongSelf.updateScheduleButtonTitle()
}
}
if !strongSelf.didSetDataReady {
strongSelf.didSetDataReady = true
strongSelf.updateMembers()
strongSelf.controller?.dataReady.set(true)
}
})
self.audioOutputStateDisposable = (self.call.audioOutputState
|> deliverOnMainQueue).start(next: { [weak self] state in
guard let strongSelf = self else {
return
}
var existingOutputs = Set<String>()
var filteredOutputs: [AudioSessionOutput] = []
for output in state.0 {
if case let .port(port) = output {
if !existingOutputs.contains(port.name) {
existingOutputs.insert(port.name)
filteredOutputs.append(output)
}
} else {
filteredOutputs.append(output)
}
}
let wasEmpty = strongSelf.audioOutputState == nil
strongSelf.audioOutputState = (filteredOutputs, state.1)
if let (layout, navigationHeight) = strongSelf.validLayout {
strongSelf.containerLayoutUpdated(layout, navigationHeight: navigationHeight, transition: .immediate)
}
if wasEmpty {
strongSelf.controller?.audioOutputStateReady.set(true)
}
})
self.audioLevelsDisposable = (self.call.audioLevels
|> deliverOnMainQueue).start(next: { [weak self] levels in
guard let strongSelf = self else {
return
}
var levels = levels
if strongSelf.effectiveMuteState != nil {
levels = levels.filter { $0.0 != strongSelf.callState?.myPeerId }
}
var maxLevelWithVideo: (PeerId, Float)?
for (peerId, source, level, hasSpeech) in levels {
let hasVideo = strongSelf.peerIdToEndpointId[peerId] != nil
if hasSpeech && source != 0 && hasVideo {
if let (_, currentLevel) = maxLevelWithVideo {
if currentLevel < level {
maxLevelWithVideo = (peerId, level)
}
} else {
maxLevelWithVideo = (peerId, level)
}
}
}
if maxLevelWithVideo == nil {
if let (peerId, _, _) = strongSelf.currentDominantSpeaker {
maxLevelWithVideo = (peerId, 0.0)
} else if strongSelf.peerIdToEndpointId.count > 0 {
for entry in strongSelf.currentFullscreenEntries {
if case let .peer(peerEntry, _) = entry {
if let _ = peerEntry.effectiveVideoEndpointId {
maxLevelWithVideo = (peerEntry.peer.id, 0.0)
break
}
}
}
}
}
if case .fullscreen = strongSelf.displayMode, !strongSelf.mainStageNode.animating && !strongSelf.animatingExpansion {
if let (peerId, _) = maxLevelWithVideo {
if let (currentPeerId, _, timestamp) = strongSelf.currentDominantSpeaker {
if CACurrentMediaTime() - timestamp > 2.5 && peerId != currentPeerId {
strongSelf.currentDominantSpeaker = (peerId, nil, CACurrentMediaTime())
strongSelf.updateMainVideo(waitForFullSize: true)
}
}
}
}
strongSelf.itemInteraction?.updateAudioLevels(levels)
})
self.myAudioLevelDisposable = (self.call.myAudioLevel
|> deliverOnMainQueue).start(next: { [weak self] level in
guard let strongSelf = self else {
return
}
var effectiveLevel: Float = 0.0
if let state = strongSelf.callState, state.muteState == nil || strongSelf.pushingToTalk {
effectiveLevel = level
} else if level > 0.1 {
effectiveLevel = level * 0.5
}
strongSelf.actionButton.updateLevel(CGFloat(effectiveLevel))
})
self.isSpeakingDisposable = (self.call.isSpeaking
|> deliverOnMainQueue).start(next: { [weak self] isSpeaking in
guard let strongSelf = self else {
return
}
if let state = strongSelf.callState, state.muteState == nil || strongSelf.pushingToTalk {
strongSelf.displayUnmuteTooltipTimer?.invalidate()
strongSelf.displayUnmuteTooltipTimer = nil
strongSelf.dismissUnmuteTooltipTimer?.invalidate()
strongSelf.dismissUnmuteTooltipTimer = nil
} else {
if isSpeaking {
var shouldDisplayTooltip = false
if let previousTimstamp = strongSelf.lastUnmuteTooltipDisplayTimestamp, CACurrentMediaTime() > previousTimstamp + 45.0 {
shouldDisplayTooltip = true
} else if strongSelf.lastUnmuteTooltipDisplayTimestamp == nil {
shouldDisplayTooltip = true
}
if shouldDisplayTooltip {
strongSelf.dismissUnmuteTooltipTimer?.invalidate()
strongSelf.dismissUnmuteTooltipTimer = nil
if strongSelf.displayUnmuteTooltipTimer == nil {
let timer = SwiftSignalKit.Timer(timeout: 1.0, repeat: false, completion: { [weak self] in
guard let strongSelf = self else {
return
}
strongSelf.lastUnmuteTooltipDisplayTimestamp = CACurrentMediaTime()
strongSelf.displayUnmuteTooltip()
strongSelf.displayUnmuteTooltipTimer?.invalidate()
strongSelf.displayUnmuteTooltipTimer = nil
strongSelf.dismissUnmuteTooltipTimer?.invalidate()
strongSelf.dismissUnmuteTooltipTimer = nil
}, queue: Queue.mainQueue())
timer.start()
strongSelf.displayUnmuteTooltipTimer = timer
}
}
} else if strongSelf.dismissUnmuteTooltipTimer == nil && strongSelf.displayUnmuteTooltipTimer != nil {
let timer = SwiftSignalKit.Timer(timeout: 0.4, repeat: false, completion: { [weak self] in
guard let strongSelf = self else {
return
}
strongSelf.displayUnmuteTooltipTimer?.invalidate()
strongSelf.displayUnmuteTooltipTimer = nil
strongSelf.dismissUnmuteTooltipTimer?.invalidate()
strongSelf.dismissUnmuteTooltipTimer = nil
}, queue: Queue.mainQueue())
timer.start()
strongSelf.dismissUnmuteTooltipTimer = timer
}
}
})
self.leaveButton.addTarget(self, action: #selector(self.leavePressed), forControlEvents: .touchUpInside)
self.actionButton.addTarget(self, action: #selector(self.actionPressed), forControlEvents: .touchUpInside)
self.audioButton.addTarget(self, action: #selector(self.audioPressed), forControlEvents: .touchUpInside)
self.cameraButton.addTarget(self, action: #selector(self.cameraPressed), forControlEvents: .touchUpInside)
self.switchCameraButton.addTarget(self, action: #selector(self.switchCameraPressed), forControlEvents: .touchUpInside)
self.optionsButton.contextAction = { [weak self] sourceNode, gesture in
self?.openSettingsMenu(sourceNode: sourceNode, gesture: gesture)
}
self.optionsButton.addTarget(self, action: #selector(self.optionsPressed), forControlEvents: .touchUpInside)
self.closeButton.addTarget(self, action: #selector(self.closePressed), forControlEvents: .touchUpInside)
self.panelButton.addTarget(self, action: #selector(self.panelPressed), forControlEvents: .touchUpInside)
self.actionButtonColorDisposable = (self.actionButton.outerColor
|> deliverOnMainQueue).start(next: { [weak self] normalColor, activeColor in
if let strongSelf = self {
let animated = strongSelf.currentNormalButtonColor != nil || strongSelf.currentActiveButtonColor == nil
strongSelf.currentNormalButtonColor = normalColor
strongSelf.currentActiveButtonColor = activeColor
strongSelf.updateButtons(transition: animated ? .animated(duration: 0.3, curve: .linear) : .immediate)
}
})
self.fullscreenListNode.updateFloatingHeaderOffset = { [weak self] _, _ in
guard let strongSelf = self else {
return
}
var visiblePeerIds = Set<PeerId>()
strongSelf.fullscreenListNode.forEachVisibleItemNode { itemNode in
if let itemNode = itemNode as? VoiceChatFullscreenParticipantItemNode, let item = itemNode.item {
if item.videoEndpointId == nil {
visiblePeerIds.insert(item.peer.id)
}
}
}
strongSelf.mainStageNode.update(visiblePeerIds: visiblePeerIds)
}
self.listNode.updateFloatingHeaderOffset = { [weak self] offset, transition in
if let strongSelf = self {
strongSelf.currentContentOffset = offset
if !(strongSelf.animatingExpansion || strongSelf.animatingInsertion || strongSelf.animatingAppearance) && (strongSelf.panGestureArguments == nil || strongSelf.isExpanded) {
strongSelf.updateDecorationsLayout(transition: transition)
}
}
}
self.listNode.visibleContentOffsetChanged = { [weak self] offset in
guard let strongSelf = self else {
return
}
var scrollAtTop = false
if case let .known(value) = offset, value < 180.0 {
scrollAtTop = true
} else {
scrollAtTop = false
}
if scrollAtTop != strongSelf.scrollAtTop {
strongSelf.scrollAtTop = scrollAtTop
strongSelf.updateTitle(transition: .immediate)
}
}
self.listNode.visibleBottomContentOffsetChanged = { [weak self] offset in
guard let strongSelf = self else {
return
}
if case let .known(value) = offset, value < 200.0 {
if let loadMoreToken = strongSelf.currentCallMembers?.1 {
strongSelf.currentLoadToken = loadMoreToken
strongSelf.call.loadMoreMembers(token: loadMoreToken)
}
}
}
self.memberEventsDisposable.set((self.call.memberEvents
|> deliverOnMainQueue).start(next: { [weak self] event in
guard let strongSelf = self else {
return
}
if event.joined {
if let channel = strongSelf.peer as? TelegramChannel, case .broadcast = channel.info {
return
}
let text = strongSelf.presentationData.strings.VoiceChat_PeerJoinedText(event.peer.displayTitle(strings: strongSelf.presentationData.strings, displayOrder: strongSelf.presentationData.nameDisplayOrder)).string
strongSelf.presentUndoOverlay(content: .invitedToVoiceChat(context: strongSelf.context, peer: event.peer, text: text, action: nil, duration: 3), action: { _ in return false })
}
}))
self.reconnectedAsEventsDisposable.set((self.call.reconnectedAsEvents
|> deliverOnMainQueue).start(next: { [weak self] peer in
guard let strongSelf = self else {
return
}
let text: String
if let channel = strongSelf.peer as? TelegramChannel, case .broadcast = channel.info {
text = strongSelf.presentationData.strings.LiveStream_DisplayAsSuccess(peer.displayTitle(strings: strongSelf.presentationData.strings, displayOrder: strongSelf.presentationData.nameDisplayOrder)).string
} else {
text = strongSelf.presentationData.strings.VoiceChat_DisplayAsSuccess(peer.displayTitle(strings: strongSelf.presentationData.strings, displayOrder: strongSelf.presentationData.nameDisplayOrder)).string
}
strongSelf.presentUndoOverlay(content: .invitedToVoiceChat(context: strongSelf.context, peer: peer, text: text, action: nil, duration: 3), action: { _ in return false })
}))
self.stateVersionDisposable.set((self.call.stateVersion
|> distinctUntilChanged
|> deliverOnMainQueue).start(next: { [weak self] _ in
guard let strongSelf = self else {
return
}
strongSelf.callStateDidReset()
}))
self.titleNode.tapped = { [weak self] in
if let strongSelf = self, !strongSelf.isScheduling {
if strongSelf.callState?.canManageCall ?? false {
strongSelf.openTitleEditing()
} else if !strongSelf.titleNode.recordingIconNode.isHidden {
var hasTooltipAlready = false
strongSelf.controller?.forEachController { controller -> Bool in
if controller is TooltipScreen {
hasTooltipAlready = true
}
return true
}
if !hasTooltipAlready {
let location = strongSelf.titleNode.recordingIconNode.convert(strongSelf.titleNode.recordingIconNode.bounds, to: nil)
let text: String
if let channel = strongSelf.peer as? TelegramChannel, case .broadcast = channel.info {
text = presentationData.strings.LiveStream_RecordingInProgress
} else {
text = presentationData.strings.VoiceChat_RecordingInProgress
}
strongSelf.controller?.present(TooltipScreen(account: strongSelf.context.account, sharedContext: strongSelf.context.sharedContext, text: .plain(text: text), icon: nil, location: .point(location.offsetBy(dx: 1.0, dy: 0.0), .top), displayDuration: .custom(3.0), shouldDismissOnTouch: { _, _ in
return .dismiss(consume: true)
}), in: .window(.root))
}
}
}
}
self.scheduleCancelButton.pressed = { [weak self] in
if let strongSelf = self {
strongSelf.dismissScheduled()
}
}
self.mainStageNode.controlsHidden = { [weak self] hidden in
if let strongSelf = self {
if hidden {
strongSelf.fullscreenListNode.alpha = 0.0
} else {
strongSelf.fullscreenListNode.alpha = 1.0
strongSelf.fullscreenListNode.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.2)
}
}
}
self.mainStageNode.tapped = { [weak self] in
if let strongSelf = self, let (layout, navigationHeight) = strongSelf.validLayout, !strongSelf.animatingExpansion && !strongSelf.animatingMainStage && !strongSelf.mainStageNode.animating {
if case .regular = layout.metrics.widthClass {
strongSelf.panelHidden = !strongSelf.panelHidden
strongSelf.animatingExpansion = true
let transition = ContainedViewLayoutTransition.animated(duration: 0.3, curve: .easeInOut)
strongSelf.containerLayoutUpdated(layout, navigationHeight: navigationHeight, transition: transition)
strongSelf.updateDecorationsLayout(transition: transition)
} else {
let effectiveDisplayMode = strongSelf.displayMode
let nextDisplayMode: DisplayMode
switch effectiveDisplayMode {
case .modal:
nextDisplayMode = effectiveDisplayMode
case let .fullscreen(controlsHidden):
if controlsHidden {
nextDisplayMode = .fullscreen(controlsHidden: false)
} else {
nextDisplayMode = .fullscreen(controlsHidden: true)
}
}
strongSelf.updateDisplayMode(nextDisplayMode)
}
}
}
self.mainStageNode.stopScreencast = { [weak self] in
if let strongSelf = self {
strongSelf.call.disableScreencast()
}
}
self.mainStageNode.back = { [weak self] in
if let strongSelf = self, !strongSelf.isPanning && !strongSelf.animatingExpansion && !strongSelf.mainStageNode.animating {
strongSelf.currentForcedSpeaker = nil
strongSelf.updateDisplayMode(.modal(isExpanded: true, isFilled: true), fromPan: true)
strongSelf.effectiveSpeaker = nil
}
}
self.mainStageNode.togglePin = { [weak self] in
if let strongSelf = self {
if let (peerId, videoEndpointId, _, _, _) = strongSelf.effectiveSpeaker {
if let _ = strongSelf.currentForcedSpeaker {
strongSelf.currentDominantSpeaker = (peerId, videoEndpointId, CACurrentMediaTime())
strongSelf.currentForcedSpeaker = nil
} else {
strongSelf.currentForcedSpeaker = (peerId, videoEndpointId)
}
}
strongSelf.updateMembers()
}
}
self.mainStageNode.switchTo = { [weak self] peerId in
if let strongSelf = self, let interaction = strongSelf.itemInteraction {
interaction.switchToPeer(peerId, nil, false)
}
}
self.mainStageNode.getAudioLevel = { [weak self] peerId in
return self?.itemInteraction?.getAudioLevel(peerId) ?? .single(0.0)
}
self.mainStageNode.getVideo = { [weak self] endpointId, isMyPeer, completion in
if let strongSelf = self {
if isMyPeer {
if strongSelf.readyVideoEndpointIds.contains(endpointId) {
completion(strongSelf.itemInteraction?.getPeerVideo(endpointId, .mainstage))
} else {
strongSelf.myPeerVideoReadyDisposable.set((strongSelf.readyVideoEndpointIdsPromise.get()
|> filter { $0.contains(endpointId) }
|> take(1)
|> deliverOnMainQueue).start(next: { [weak self] _ in
if let strongSelf = self {
completion(strongSelf.itemInteraction?.getPeerVideo(endpointId, .mainstage))
}
}))
}
} else {
if let input = (strongSelf.call as! PresentationGroupCallImpl).video(endpointId: endpointId) {
if let videoView = strongSelf.videoRenderingContext.makeView(input: input, blur: false) {
completion(GroupVideoNode(videoView: videoView, backdropVideoView: strongSelf.videoRenderingContext.makeView(input: input, blur: true)))
}
}
/*strongSelf.call.makeIncomingVideoView(endpointId: endpointId, requestClone: GroupVideoNode.useBlurTransparency, completion: { videoView, backdropVideoView in
if let videoView = videoView {
completion(GroupVideoNode(videoView: videoView, backdropVideoView: backdropVideoView))
} else {
completion(nil)
}
})*/
}
}
}
self.applicationStateDisposable = (self.context.sharedContext.applicationBindings.applicationIsActive
|> deliverOnMainQueue).start(next: { [weak self] active in
guard let strongSelf = self else {
return
}
strongSelf.appIsActive = active
})
if self.context.sharedContext.immediateExperimentalUISettings.enableDebugDataDisplay {
self.statsDisposable = ((call as! PresentationGroupCallImpl).getStats()
|> deliverOnMainQueue
|> then(.complete() |> delay(1.0, queue: .mainQueue()))
|> restart).start(next: { [weak self] stats in
guard let strongSelf = self else {
return
}
for (endpointId, videoNode) in strongSelf.videoNodes {
if let incomingVideoStats = stats.incomingVideoStats[endpointId] {
videoNode.updateDebugInfo(text: "in: \(incomingVideoStats.receivingQuality)\n srv: \(incomingVideoStats.availableQuality)")
}
}
if let (_, maybeEndpointId, _, _, _) = strongSelf.mainStageNode.currentPeer, let endpointId = maybeEndpointId {
if let incomingVideoStats = stats.incomingVideoStats[endpointId] {
strongSelf.mainStageNode.currentVideoNode?.updateDebugInfo(text: "in: \(incomingVideoStats.receivingQuality)\n srv: \(incomingVideoStats.availableQuality)")
}
}
})
}
}
deinit {
self.presentationDataDisposable?.dispose()
self.peerViewDisposable?.dispose()
self.leaveDisposable.dispose()
self.isMutedDisposable?.dispose()
self.isNoiseSuppressionEnabledDisposable?.dispose()
self.callStateDisposable?.dispose()
self.audioOutputStateDisposable?.dispose()
self.memberStatesDisposable?.dispose()
self.audioLevelsDisposable?.dispose()
self.myAudioLevelDisposable?.dispose()
self.isSpeakingDisposable?.dispose()
self.inviteDisposable.dispose()
self.memberEventsDisposable.dispose()
self.reconnectedAsEventsDisposable.dispose()
self.stateVersionDisposable.dispose()
self.updateAvatarDisposable.dispose()
self.ignoreConnectingTimer?.invalidate()
self.readyVideoDisposables.dispose()
self.applicationStateDisposable?.dispose()
self.myPeerVideoReadyDisposable.dispose()
self.statsDisposable?.dispose()
}
private func openSettingsMenu(sourceNode: ASDisplayNode, gesture: ContextGesture?) {
let items: Signal<[ContextMenuItem], NoError> = self.contextMenuMainItems()
if let controller = self.controller {
let contextController = ContextController(presentationData: self.presentationData.withUpdated(theme: self.darkTheme), source: .reference(VoiceChatContextReferenceContentSource(controller: controller, sourceNode: self.optionsButton.referenceNode)), items: items |> map { ContextController.Items(content: .list($0)) }, gesture: gesture)
controller.presentInGlobalOverlay(contextController)
}
}
private func contextMenuMainItems() -> Signal<[ContextMenuItem], NoError> {
guard let myPeerId = self.callState?.myPeerId else {
return .single([])
}
let canManageCall = self.callState?.canManageCall == true
let avatarSize = CGSize(width: 28.0, height: 28.0)
return combineLatest(self.displayAsPeersPromise.get(), self.context.account.postbox.loadedPeerWithId(self.call.peerId), self.inviteLinksPromise.get())
|> take(1)
|> deliverOnMainQueue
|> map { [weak self] peers, chatPeer, inviteLinks -> [ContextMenuItem] in
guard let strongSelf = self else {
return []
}
var items: [ContextMenuItem] = []
if peers.count > 1 {
for peer in peers {
if peer.peer.id == myPeerId {
items.append(.action(ContextMenuActionItem(text: strongSelf.presentationData.strings.VoiceChat_DisplayAs, textLayout: .secondLineWithValue(EnginePeer(peer.peer).displayTitle(strings: strongSelf.presentationData.strings, displayOrder: strongSelf.presentationData.nameDisplayOrder)), icon: { _ in nil }, iconSource: ContextMenuActionItemIconSource(size: avatarSize, signal: peerAvatarCompleteImage(account: strongSelf.context.account, peer: EnginePeer(peer.peer), size: avatarSize)), action: { c, _ in
guard let strongSelf = self else {
return
}
c?.setItems(strongSelf.contextMenuDisplayAsItems() |> map { ContextController.Items(content: .list($0)) }, minHeight: nil, animated: true)
})))
items.append(.separator)
break
}
}
}
if let (availableOutputs, currentOutput) = strongSelf.audioOutputState, availableOutputs.count > 1 {
var currentOutputTitle = ""
for output in availableOutputs {
if output == currentOutput {
let title: String
switch output {
case .builtin:
title = UIDevice.current.model
case .speaker:
title = strongSelf.presentationData.strings.Call_AudioRouteSpeaker
case .headphones:
title = strongSelf.presentationData.strings.Call_AudioRouteHeadphones
case let .port(port):
title = port.name
}
currentOutputTitle = title
break
}
}
items.append(.action(ContextMenuActionItem(text: strongSelf.presentationData.strings.VoiceChat_ContextAudio, textLayout: .secondLineWithValue(currentOutputTitle), icon: { theme in
return generateTintedImage(image: UIImage(bundleImageName: "Call/Context Menu/Audio"), color: theme.actionSheet.primaryTextColor)
}, action: { c, _ in
guard let strongSelf = self else {
return
}
c?.setItems(strongSelf.contextMenuAudioItems() |> map { ContextController.Items(content: .list($0)) }, minHeight: nil, animated: true)
})))
}
if canManageCall {
let text: String
if let channel = strongSelf.peer as? TelegramChannel, case .broadcast = channel.info {
text = strongSelf.presentationData.strings.LiveStream_EditTitle
} else {
text = strongSelf.presentationData.strings.VoiceChat_EditTitle
}
items.append(.action(ContextMenuActionItem(text: text, icon: { theme -> UIImage? in
return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Pencil"), color: theme.actionSheet.primaryTextColor)
}, action: { _, f in
f(.default)
guard let strongSelf = self else {
return
}
strongSelf.openTitleEditing()
})))
var hasPermissions = true
if let chatPeer = chatPeer as? TelegramChannel {
if case .broadcast = chatPeer.info {
hasPermissions = false
} else if chatPeer.flags.contains(.isGigagroup) {
hasPermissions = false
}
}
if hasPermissions {
items.append(.action(ContextMenuActionItem(text: strongSelf.presentationData.strings.VoiceChat_EditPermissions, icon: { theme -> UIImage? in
return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Restrict"), color: theme.actionSheet.primaryTextColor)
}, action: { c, _ in
guard let strongSelf = self else {
return
}
c?.setItems(strongSelf.contextMenuPermissionItems() |> map { ContextController.Items(content: .list($0)) }, minHeight: nil, animated: true)
})))
}
}
if let inviteLinks = inviteLinks {
items.append(.action(ContextMenuActionItem(text: strongSelf.presentationData.strings.VoiceChat_Share, icon: { theme in
return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Link"), color: theme.actionSheet.primaryTextColor)
}, action: { _, f in
f(.default)
self?.presentShare(inviteLinks)
})))
}
let isScheduled = strongSelf.isScheduled
let canSpeak: Bool
if let callState = strongSelf.callState {
if let muteState = callState.muteState {
canSpeak = muteState.canUnmute
} else {
canSpeak = true
}
} else {
canSpeak = false
}
if !isScheduled && canSpeak {
items.append(.action(ContextMenuActionItem(text: strongSelf.presentationData.strings.VoiceChat_NoiseSuppression, textColor: .primary, textLayout: .secondLineWithValue(strongSelf.isNoiseSuppressionEnabled ? strongSelf.presentationData.strings.VoiceChat_NoiseSuppressionEnabled : strongSelf.presentationData.strings.VoiceChat_NoiseSuppressionDisabled), icon: { theme in
return generateTintedImage(image: UIImage(bundleImageName: "Call/Context Menu/Noise"), color: theme.actionSheet.primaryTextColor)
}, action: { _, f in
f(.dismissWithoutContent)
if let strongSelf = self {
strongSelf.call.setIsNoiseSuppressionEnabled(!strongSelf.isNoiseSuppressionEnabled)
}
})))
}
if let callState = strongSelf.callState, callState.isVideoEnabled && (callState.muteState?.canUnmute ?? true) {
if #available(iOS 12.0, *) {
if strongSelf.call.hasScreencast {
items.append(.action(ContextMenuActionItem(text: strongSelf.presentationData.strings.VoiceChat_StopScreenSharing, icon: { theme in
return generateTintedImage(image: UIImage(bundleImageName: "Call/Context Menu/ShareScreen"), color: theme.actionSheet.primaryTextColor)
}, action: { _, f in
f(.default)
self?.call.disableScreencast()
})))
} else {
items.append(.custom(VoiceChatShareScreenContextItem(context: strongSelf.context, text: strongSelf.presentationData.strings.VoiceChat_ShareScreen, icon: { theme in
return generateTintedImage(image: UIImage(bundleImageName: "Call/Context Menu/ShareScreen"), color: theme.actionSheet.primaryTextColor)
}, action: { _, _ in }), false))
}
}
}
if canManageCall {
if let recordingStartTimestamp = strongSelf.callState?.recordingStartTimestamp {
items.append(.custom(VoiceChatRecordingContextItem(timestamp: recordingStartTimestamp, action: { _, f in
f(.dismissWithoutContent)
guard let strongSelf = self else {
return
}
let alertController = textAlertController(context: strongSelf.context, forceTheme: strongSelf.darkTheme, title: nil, text: strongSelf.presentationData.strings.VoiceChat_StopRecordingTitle, actions: [TextAlertAction(type: .genericAction, title: strongSelf.presentationData.strings.Common_Cancel, action: {}), TextAlertAction(type: .defaultAction, title: strongSelf.presentationData.strings.VoiceChat_StopRecordingStop, action: {
if let strongSelf = self {
strongSelf.call.setShouldBeRecording(false, title: nil, videoOrientation: nil)
Queue.mainQueue().after(0.88) {
strongSelf.hapticFeedback.success()
}
let text: String
if let channel = strongSelf.peer as? TelegramChannel, case .broadcast = channel.info {
text = strongSelf.presentationData.strings.LiveStream_RecordingSaved
} else {
text = strongSelf.presentationData.strings.VideoChat_RecordingSaved
}
strongSelf.presentUndoOverlay(content: .forward(savedMessages: true, text: text), action: { [weak self] value in
if case .info = value, let strongSelf = self, let navigationController = strongSelf.controller?.navigationController as? NavigationController {
let context = strongSelf.context
strongSelf.controller?.dismiss(completion: {
Queue.mainQueue().justDispatch {
let _ = (context.engine.data.get(TelegramEngine.EngineData.Item.Peer.Peer(id: context.account.peerId))
|> deliverOnMainQueue).start(next: { peer in
guard let peer = peer else {
return
}
context.sharedContext.navigateToChatController(NavigateToChatControllerParams(navigationController: navigationController, context: context, chatLocation: .peer(peer), keepStack: .always, purposefulAction: {}, peekData: nil))
})
}
})
return true
}
return false
})
}
})])
self?.controller?.present(alertController, in: .window(.root))
}), false))
} else {
let text: String
if let channel = strongSelf.peer as? TelegramChannel, case .broadcast = channel.info {
text = strongSelf.presentationData.strings.LiveStream_StartRecording
} else {
text = strongSelf.presentationData.strings.VoiceChat_StartRecording
}
if strongSelf.callState?.scheduleTimestamp == nil {
items.append(.action(ContextMenuActionItem(text: text, icon: { theme -> UIImage? in
return generateStartRecordingIcon(color: theme.actionSheet.primaryTextColor)
}, action: { _, f in
f(.dismissWithoutContent)
guard let strongSelf = self, let peer = strongSelf.peer else {
return
}
let controller = VoiceChatRecordingSetupController(context: strongSelf.context, peer: EnginePeer(peer), completion: { [weak self] videoOrientation in
if let strongSelf = self {
let title: String
let text: String
let placeholder: String
if let _ = videoOrientation {
placeholder = strongSelf.presentationData.strings.VoiceChat_RecordingTitlePlaceholderVideo
} else {
placeholder = strongSelf.presentationData.strings.VoiceChat_RecordingTitlePlaceholder
}
if let channel = strongSelf.peer as? TelegramChannel, case .broadcast = channel.info {
title = strongSelf.presentationData.strings.LiveStream_StartRecordingTitle
if let _ = videoOrientation {
text = strongSelf.presentationData.strings.LiveStream_StartRecordingTextVideo
} else {
text = strongSelf.presentationData.strings.LiveStream_StartRecordingText
}
} else {
title = strongSelf.presentationData.strings.VoiceChat_StartRecordingTitle
if let _ = videoOrientation {
text = strongSelf.presentationData.strings.VoiceChat_StartRecordingTextVideo
} else {
text = strongSelf.presentationData.strings.VoiceChat_StartRecordingText
}
}
let controller = voiceChatTitleEditController(sharedContext: strongSelf.context.sharedContext, account: strongSelf.context.account, forceTheme: strongSelf.darkTheme, title: title, text: text, placeholder: placeholder, value: nil, maxLength: 40, apply: { title in
if let strongSelf = self, let title = title {
strongSelf.call.setShouldBeRecording(true, title: title, videoOrientation: videoOrientation)
let text: String
if let channel = strongSelf.peer as? TelegramChannel, case .broadcast = channel.info {
text = strongSelf.presentationData.strings.LiveStream_RecordingStarted
} else {
text = strongSelf.presentationData.strings.VoiceChat_RecordingStarted
}
strongSelf.presentUndoOverlay(content: .voiceChatRecording(text: text), action: { _ in return false })
strongSelf.call.playTone(.recordingStarted)
}
})
strongSelf.controller?.present(controller, in: .window(.root))
}
})
self?.controller?.present(controller, in: .window(.root))
})))
}
}
}
if canManageCall {
let text: String
if let channel = strongSelf.peer as? TelegramChannel, case .broadcast = channel.info {
text = isScheduled ? strongSelf.presentationData.strings.VoiceChat_CancelLiveStream : strongSelf.presentationData.strings.VoiceChat_EndLiveStream
} else {
text = isScheduled ? strongSelf.presentationData.strings.VoiceChat_CancelVoiceChat : strongSelf.presentationData.strings.VoiceChat_EndVoiceChat
}
items.append(.action(ContextMenuActionItem(text: text, textColor: .destructive, icon: { theme in
return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Clear"), color: theme.actionSheet.destructiveActionTextColor)
}, action: { _, f in
f(.dismissWithoutContent)
guard let strongSelf = self else {
return
}
let action: () -> Void = {
guard let strongSelf = self else {
return
}
let _ = (strongSelf.call.leave(terminateIfPossible: true)
|> filter { $0 }
|> take(1)
|> deliverOnMainQueue).start(completed: {
self?.controller?.dismiss()
})
}
let title: String
let text: String
if let channel = strongSelf.peer as? TelegramChannel, case .broadcast = channel.info {
title = isScheduled ? strongSelf.presentationData.strings.LiveStream_CancelConfirmationTitle : strongSelf.presentationData.strings.LiveStream_EndConfirmationTitle
text = isScheduled ? strongSelf.presentationData.strings.LiveStream_CancelConfirmationText : strongSelf.presentationData.strings.LiveStream_EndConfirmationText
} else {
title = isScheduled ? strongSelf.presentationData.strings.VoiceChat_CancelConfirmationTitle : strongSelf.presentationData.strings.VoiceChat_EndConfirmationTitle
text = isScheduled ? strongSelf.presentationData.strings.VoiceChat_CancelConfirmationText : strongSelf.presentationData.strings.VoiceChat_EndConfirmationText
}
let alertController = textAlertController(context: strongSelf.context, forceTheme: strongSelf.darkTheme, title: title, text: text, actions: [TextAlertAction(type: .defaultAction, title: strongSelf.presentationData.strings.Common_Cancel, action: {}), TextAlertAction(type: .genericAction, title: isScheduled ? strongSelf.presentationData.strings.VoiceChat_CancelConfirmationEnd : strongSelf.presentationData.strings.VoiceChat_EndConfirmationEnd, action: {
action()
})])
strongSelf.controller?.present(alertController, in: .window(.root))
})))
} else {
let leaveText: String
if let channel = strongSelf.peer as? TelegramChannel, case .broadcast = channel.info {
leaveText = strongSelf.presentationData.strings.LiveStream_LeaveVoiceChat
} else {
leaveText = strongSelf.presentationData.strings.VoiceChat_LeaveVoiceChat
}
items.append(.action(ContextMenuActionItem(text: leaveText, textColor: .destructive, icon: { theme in
return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Clear"), color: theme.actionSheet.destructiveActionTextColor)
}, action: { _, f in
f(.dismissWithoutContent)
guard let strongSelf = self else {
return
}
let _ = (strongSelf.call.leave(terminateIfPossible: false)
|> filter { $0 }
|> take(1)
|> deliverOnMainQueue).start(completed: {
self?.controller?.dismiss()
})
})))
}
return items
}
}
private func contextMenuAudioItems() -> Signal<[ContextMenuItem], NoError> {
guard let (availableOutputs, currentOutput) = self.audioOutputState else {
return .single([])
}
var items: [ContextMenuItem] = []
for output in availableOutputs {
let title: String
switch output {
case .builtin:
title = UIDevice.current.model
case .speaker:
title = self.presentationData.strings.Call_AudioRouteSpeaker
case .headphones:
title = self.presentationData.strings.Call_AudioRouteHeadphones
case let .port(port):
title = port.name
}
items.append(.action(ContextMenuActionItem(text: title, icon: { theme in
if output == currentOutput {
return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Check"), color: theme.actionSheet.primaryTextColor)
} else {
return nil
}
}, action: { [weak self] _, f in
f(.default)
self?.call.setCurrentAudioOutput(output)
})))
}
items.append(.separator)
items.append(.action(ContextMenuActionItem(text: self.presentationData.strings.Common_Back, icon: { theme in
return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Back"), color: theme.actionSheet.primaryTextColor)
}, iconPosition: .left, action: { [weak self] (c, _) in
guard let strongSelf = self else {
return
}
c?.setItems(strongSelf.contextMenuMainItems() |> map { ContextController.Items(content: .list($0)) }, minHeight: nil, animated: true)
})))
return .single(items)
}
private func contextMenuDisplayAsItems() -> Signal<[ContextMenuItem], NoError> {
guard let myPeerId = self.callState?.myPeerId else {
return .single([])
}
let avatarSize = CGSize(width: 28.0, height: 28.0)
let darkTheme = self.darkTheme
return self.displayAsPeersPromise.get()
|> take(1)
|> map { [weak self] peers -> [ContextMenuItem] in
guard let strongSelf = self else {
return []
}
var items: [ContextMenuItem] = []
var isGroup = false
for peer in peers {
if peer.peer is TelegramGroup {
isGroup = true
break
} else if let peer = peer.peer as? TelegramChannel, case .group = peer.info {
isGroup = true
break
}
}
items.append(.custom(VoiceChatInfoContextItem(text: isGroup ? strongSelf.presentationData.strings.VoiceChat_DisplayAsInfoGroup : strongSelf.presentationData.strings.VoiceChat_DisplayAsInfo, icon: { theme in
return generateTintedImage(image: UIImage(bundleImageName: "Call/Context Menu/Accounts"), color: theme.actionSheet.primaryTextColor)
}), true))
for peer in peers {
var subtitle: String?
if peer.peer.id.namespace == Namespaces.Peer.CloudUser {
subtitle = strongSelf.presentationData.strings.VoiceChat_PersonalAccount
} else if let subscribers = peer.subscribers {
if let peer = peer.peer as? TelegramChannel, case .broadcast = peer.info {
subtitle = strongSelf.presentationData.strings.Conversation_StatusSubscribers(subscribers)
} else {
subtitle = strongSelf.presentationData.strings.Conversation_StatusMembers(subscribers)
}
}
let isSelected = peer.peer.id == myPeerId
let extendedAvatarSize = CGSize(width: 35.0, height: 35.0)
let avatarSignal = peerAvatarCompleteImage(account: strongSelf.context.account, peer: EnginePeer(peer.peer), size: avatarSize)
|> map { image -> UIImage? in
if isSelected, let image = image {
return generateImage(extendedAvatarSize, rotatedContext: { size, context in
let bounds = CGRect(origin: CGPoint(), size: size)
context.clear(bounds)
context.translateBy(x: size.width / 2.0, y: size.height / 2.0)
context.scaleBy(x: 1.0, y: -1.0)
context.translateBy(x: -size.width / 2.0, y: -size.height / 2.0)
context.draw(image.cgImage!, in: CGRect(x: (extendedAvatarSize.width - avatarSize.width) / 2.0, y: (extendedAvatarSize.height - avatarSize.height) / 2.0, width: avatarSize.width, height: avatarSize.height))
let lineWidth = 1.0 + UIScreenPixel
context.setLineWidth(lineWidth)
context.setStrokeColor(darkTheme.actionSheet.controlAccentColor.cgColor)
context.strokeEllipse(in: bounds.insetBy(dx: lineWidth / 2.0, dy: lineWidth / 2.0))
})
} else {
return image
}
}
items.append(.action(ContextMenuActionItem(text: EnginePeer(peer.peer).displayTitle(strings: strongSelf.presentationData.strings, displayOrder: strongSelf.presentationData.nameDisplayOrder), textLayout: subtitle.flatMap { .secondLineWithValue($0) } ?? .singleLine, icon: { _ in nil }, iconSource: ContextMenuActionItemIconSource(size: isSelected ? extendedAvatarSize : avatarSize, signal: avatarSignal), action: { _, f in
f(.default)
guard let strongSelf = self else {
return
}
if peer.peer.id != myPeerId {
strongSelf.call.reconnect(as: peer.peer.id)
}
})))
if peer.peer.id.namespace == Namespaces.Peer.CloudUser {
items.append(.separator)
}
}
items.append(.separator)
items.append(.action(ContextMenuActionItem(text: strongSelf.presentationData.strings.Common_Back, icon: { theme in
return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Back"), color: theme.actionSheet.primaryTextColor)
}, iconPosition: .left, action: { (c, _) in
guard let strongSelf = self else {
return
}
c?.setItems(strongSelf.contextMenuMainItems() |> map { ContextController.Items(content: .list($0)) }, minHeight: nil, animated: true)
})))
return items
}
}
private func contextMenuPermissionItems() -> Signal<[ContextMenuItem], NoError> {
var items: [ContextMenuItem] = []
if let callState = self.callState, callState.canManageCall, let defaultParticipantMuteState = callState.defaultParticipantMuteState {
let isMuted = defaultParticipantMuteState == .muted
items.append(.action(ContextMenuActionItem(text: self.presentationData.strings.VoiceChat_SpeakPermissionEveryone, icon: { theme in
if isMuted {
return nil
} else {
return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Check"), color: theme.actionSheet.primaryTextColor)
}
}, action: { [weak self] _, f in
f(.dismissWithoutContent)
guard let strongSelf = self else {
return
}
strongSelf.call.updateDefaultParticipantsAreMuted(isMuted: false)
})))
items.append(.action(ContextMenuActionItem(text: self.presentationData.strings.VoiceChat_SpeakPermissionAdmin, icon: { theme in
if !isMuted {
return nil
} else {
return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Check"), color: theme.actionSheet.primaryTextColor)
}
}, action: { [weak self] _, f in
f(.dismissWithoutContent)
guard let strongSelf = self else {
return
}
strongSelf.call.updateDefaultParticipantsAreMuted(isMuted: true)
})))
items.append(.separator)
items.append(.action(ContextMenuActionItem(text: self.presentationData.strings.Common_Back, icon: { theme in
return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Back"), color: theme.actionSheet.primaryTextColor)
}, iconPosition: .left, action: { [weak self] (c, _) in
guard let strongSelf = self else {
return
}
c?.setItems(strongSelf.contextMenuMainItems() |> map { ContextController.Items(content: .list($0)) }, minHeight: nil, animated: true)
})))
}
return .single(items)
}
override func didLoad() {
super.didLoad()
self.view.disablesInteractiveTransitionGestureRecognizer = true
self.view.disablesInteractiveModalDismiss = true
self.dimNode.view.addGestureRecognizer(UITapGestureRecognizer(target: self, action: #selector(self.dimTapGesture(_:))))
let longTapRecognizer = UILongPressGestureRecognizer(target: self, action: #selector(self.actionButtonPressGesture(_:)))
longTapRecognizer.minimumPressDuration = 0.001
longTapRecognizer.delegate = self.wrappedGestureRecognizerDelegate
self.actionButton.view.addGestureRecognizer(longTapRecognizer)
let panRecognizer = DirectionalPanGestureRecognizer(target: self, action: #selector(self.panGesture(_:)))
panRecognizer.delegate = self.wrappedGestureRecognizerDelegate
panRecognizer.delaysTouchesBegan = false
panRecognizer.cancelsTouchesInView = true
self.view.addGestureRecognizer(panRecognizer)
if self.isScheduling {
self.setupSchedulePickerView()
self.updateScheduleButtonTitle()
}
}
private func updateSchedulePickerLimits() {
let timeZone = TimeZone(secondsFromGMT: 0)!
var calendar = Calendar(identifier: .gregorian)
calendar.timeZone = timeZone
let currentDate = Date()
var components = calendar.dateComponents(Set([.era, .year, .month, .day, .hour, .minute, .second]), from: currentDate)
components.second = 0
let roundedDate = calendar.date(from: components)!
let next1MinDate = calendar.date(byAdding: .minute, value: 1, to: roundedDate)
let minute = components.minute ?? 0
components.minute = 0
let roundedToHourDate = calendar.date(from: components)!
components.hour = 0
let roundedToMidnightDate = calendar.date(from: components)!
let nextTwoHourDate = calendar.date(byAdding: .hour, value: minute > 30 ? 4 : 3, to: roundedToHourDate)
let maxDate = calendar.date(byAdding: .day, value: 8, to: roundedToMidnightDate)
if let date = calendar.date(byAdding: .day, value: 365, to: currentDate) {
self.pickerView?.maximumDate = date
}
if let next1MinDate = next1MinDate, let nextTwoHourDate = nextTwoHourDate {
self.pickerView?.minimumDate = next1MinDate
self.pickerView?.maximumDate = maxDate
self.pickerView?.date = nextTwoHourDate
}
}
private func setupSchedulePickerView() {
var currentDate: Date?
if let pickerView = self.pickerView {
currentDate = pickerView.date
pickerView.removeFromSuperview()
}
let textColor = UIColor.white
UILabel.setDateLabel(textColor)
let pickerView = UIDatePicker()
pickerView.timeZone = TimeZone(secondsFromGMT: 0)
pickerView.datePickerMode = .countDownTimer
pickerView.datePickerMode = .dateAndTime
pickerView.locale = Locale.current
pickerView.timeZone = TimeZone.current
pickerView.minuteInterval = 1
self.contentContainer.view.addSubview(pickerView)
pickerView.addTarget(self, action: #selector(self.scheduleDatePickerUpdated), for: .valueChanged)
if #available(iOS 13.4, *) {
pickerView.preferredDatePickerStyle = .wheels
}
pickerView.setValue(textColor, forKey: "textColor")
self.pickerView = pickerView
self.updateSchedulePickerLimits()
if let currentDate = currentDate {
pickerView.date = currentDate
}
}
private let calendar = Calendar(identifier: .gregorian)
private func updateScheduleButtonTitle() {
guard let date = self.pickerView?.date else {
return
}
let calendar = Calendar(identifier: .gregorian)
let currentTimestamp = Int32(CFAbsoluteTimeGetCurrent() + kCFAbsoluteTimeIntervalSince1970)
let timestamp = Int32(date.timeIntervalSince1970)
let time = stringForMessageTimestamp(timestamp: timestamp, dateTimeFormat: self.presentationData.dateTimeFormat)
let buttonTitle: String
if calendar.isDateInToday(date) {
buttonTitle = self.presentationData.strings.ScheduleVoiceChat_ScheduleToday(time).string
} else if calendar.isDateInTomorrow(date) {
buttonTitle = self.presentationData.strings.ScheduleVoiceChat_ScheduleTomorrow(time).string
} else {
buttonTitle = self.presentationData.strings.ScheduleVoiceChat_ScheduleOn(self.dateFormatter.string(from: date), time).string
}
self.scheduleButtonTitle = buttonTitle
let delta = timestamp - currentTimestamp
var isGroup = true
if let peer = self.peer as? TelegramChannel, case .broadcast = peer.info {
isGroup = false
}
let intervalString = scheduledTimeIntervalString(strings: self.presentationData.strings, value: max(60, delta))
self.scheduleTextNode.attributedText = NSAttributedString(string: isGroup ? self.presentationData.strings.ScheduleVoiceChat_GroupText(intervalString).string : self.presentationData.strings.ScheduleLiveStream_ChannelText(intervalString).string, font: Font.regular(14.0), textColor: UIColor(rgb: 0x8e8e93))
if let (layout, navigationHeight) = self.validLayout {
self.containerLayoutUpdated(layout, navigationHeight: navigationHeight, transition: .animated(duration: 0.3, curve: .spring))
}
}
@objc private func scheduleDatePickerUpdated() {
self.updateScheduleButtonTitle()
}
private func schedule() {
if let date = self.pickerView?.date, date > Date() {
self.call.schedule(timestamp: Int32(date.timeIntervalSince1970))
self.isScheduling = false
self.transitionToScheduled()
if let (layout, navigationHeight) = self.validLayout {
self.containerLayoutUpdated(layout, navigationHeight: navigationHeight, transition: .animated(duration: 0.3, curve: .spring))
}
}
}
private func dismissScheduled() {
self.leaveDisposable.set((self.call.leave(terminateIfPossible: true)
|> deliverOnMainQueue).start(completed: { [weak self] in
self?.controller?.dismiss(closing: true)
}))
}
private func transitionToScheduled() {
let springDuration: Double = 0.6
let springDamping: CGFloat = 100.0
self.optionsButton.alpha = 1.0
self.optionsButton.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.2)
self.optionsButton.layer.animateSpring(from: 0.01 as NSNumber, to: 1.0 as NSNumber, keyPath: "transform.scale", duration: springDuration, damping: springDamping)
self.optionsButton.isUserInteractionEnabled = true
self.closeButton.alpha = 1.0
self.closeButton.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.2)
self.closeButton.layer.animateSpring(from: 0.01 as NSNumber, to: 1.0 as NSNumber, keyPath: "transform.scale", duration: springDuration, damping: springDamping)
self.closeButton.isUserInteractionEnabled = true
self.audioButton.alpha = 1.0
self.audioButton.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.2)
self.audioButton.layer.animateSpring(from: 0.01 as NSNumber, to: 1.0 as NSNumber, keyPath: "transform.scale", duration: springDuration, damping: springDamping)
self.audioButton.isUserInteractionEnabled = true
self.leaveButton.alpha = 1.0
self.leaveButton.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.2)
self.leaveButton.layer.animateSpring(from: 0.01 as NSNumber, to: 1.0 as NSNumber, keyPath: "transform.scale", duration: springDuration, damping: springDamping)
self.leaveButton.isUserInteractionEnabled = true
self.scheduleCancelButton.alpha = 0.0
self.scheduleCancelButton.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.15)
self.scheduleCancelButton.layer.animatePosition(from: CGPoint(), to: CGPoint(x: 0.0, y: 26.0), duration: 0.2, removeOnCompletion: false, additive: true)
self.actionButton.titleLabel.layer.animatePosition(from: CGPoint(x: 0.0, y: -26.0), to: CGPoint(), duration: 0.2, additive: true)
if let pickerView = self.pickerView {
self.pickerView = nil
pickerView.alpha = 0.0
pickerView.layer.animateScale(from: 1.0, to: 0.25, duration: 0.15, removeOnCompletion: false)
pickerView.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.2, removeOnCompletion: false, completion: { [weak pickerView] _ in
pickerView?.removeFromSuperview()
})
pickerView.isUserInteractionEnabled = false
}
self.timerNode.isHidden = false
self.timerNode.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.25)
self.timerNode.animateIn()
self.scheduleTextNode.alpha = 0.0
self.scheduleTextNode.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.25)
self.updateTitle(slide: true, transition: .animated(duration: 0.2, curve: .easeInOut))
}
private func transitionToCall() {
self.updateDecorationsColors()
self.listNode.alpha = 1.0
self.listNode.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.2)
self.listNode.isUserInteractionEnabled = true
self.timerNode.alpha = 0.0
self.timerNode.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.2, completion: { [weak self] _ in
self?.timerNode.isHidden = true
})
if self.audioButton.isHidden {
self.audioButton.isHidden = false
self.audioButton.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.2)
self.audioButton.layer.animateSpring(from: 0.01 as NSNumber, to: 1.0 as NSNumber, keyPath: "transform.scale", duration: 0.6, damping: 100.0)
}
self.updateTitle(transition: .animated(duration: 0.2, curve: .easeInOut))
}
@objc private func optionsPressed() {
self.optionsButton.play()
self.optionsButton.contextAction?(self.optionsButton.containerNode, nil)
}
@objc private func closePressed() {
self.controller?.dismiss(closing: false)
self.controller?.dismissAllTooltips()
}
@objc private func panelPressed() {
guard let (layout, navigationHeight) = self.validLayout, !self.animatingExpansion && !self.animatingMainStage && !self.mainStageNode.animating else {
return
}
self.panelHidden = !self.panelHidden
self.animatingExpansion = true
let transition = ContainedViewLayoutTransition.animated(duration: 0.3, curve: .easeInOut)
self.containerLayoutUpdated(layout, navigationHeight: navigationHeight, transition: transition)
self.updateDecorationsLayout(transition: transition)
}
@objc private func leavePressed() {
self.hapticFeedback.impact(.light)
self.controller?.dismissAllTooltips()
if let callState = self.callState, callState.canManageCall {
let action: () -> Void = { [weak self] in
guard let strongSelf = self else {
return
}
strongSelf.leaveDisposable.set((strongSelf.call.leave(terminateIfPossible: true)
|> deliverOnMainQueue).start(completed: {
self?.controller?.dismiss()
}))
}
let actionSheet = ActionSheetController(presentationData: self.presentationData.withUpdated(theme: self.darkTheme))
var items: [ActionSheetItem] = []
let leaveTitle: String
let leaveAndCancelTitle: String
if let channel = self.peer as? TelegramChannel, case .broadcast = channel.info {
leaveTitle = self.presentationData.strings.LiveStream_LeaveConfirmation
leaveAndCancelTitle = self.isScheduled ? self.presentationData.strings.LiveStream_LeaveAndCancelVoiceChat : self.presentationData.strings.LiveStream_LeaveAndEndVoiceChat
} else {
leaveTitle = self.presentationData.strings.VoiceChat_LeaveConfirmation
leaveAndCancelTitle = self.isScheduled ? self.presentationData.strings.VoiceChat_LeaveAndCancelVoiceChat : self.presentationData.strings.VoiceChat_LeaveAndEndVoiceChat
}
items.append(ActionSheetTextItem(title: leaveTitle))
items.append(ActionSheetButtonItem(title: leaveAndCancelTitle, color: .destructive, action: { [weak self, weak actionSheet] in
actionSheet?.dismissAnimated()
if let strongSelf = self {
let title: String
let text: String
if let channel = strongSelf.peer as? TelegramChannel, case .broadcast = channel.info {
title = strongSelf.isScheduled ? strongSelf.presentationData.strings.LiveStream_CancelConfirmationTitle : strongSelf.presentationData.strings.LiveStream_EndConfirmationTitle
text = strongSelf.isScheduled ? strongSelf.presentationData.strings.LiveStream_CancelConfirmationText : strongSelf.presentationData.strings.LiveStream_EndConfirmationText
} else {
title = strongSelf.isScheduled ? strongSelf.presentationData.strings.VoiceChat_CancelConfirmationTitle : strongSelf.presentationData.strings.VoiceChat_EndConfirmationTitle
text = strongSelf.isScheduled ? strongSelf.presentationData.strings.VoiceChat_CancelConfirmationText : strongSelf.presentationData.strings.VoiceChat_EndConfirmationText
}
if let (members, _) = strongSelf.currentCallMembers, members.count >= 10 || true {
let alertController = textAlertController(context: strongSelf.context, forceTheme: strongSelf.darkTheme, title: title, text: text, actions: [TextAlertAction(type: .defaultAction, title: strongSelf.presentationData.strings.Common_Cancel, action: {}), TextAlertAction(type: .genericAction, title: strongSelf.isScheduled ? strongSelf.presentationData.strings.VoiceChat_CancelConfirmationEnd : strongSelf.presentationData.strings.VoiceChat_EndConfirmationEnd, action: {
action()
})])
strongSelf.controller?.present(alertController, in: .window(.root))
} else {
action()
}
}
}))
let leaveText: String
if let channel = self.peer as? TelegramChannel, case .broadcast = channel.info {
leaveText = self.presentationData.strings.LiveStream_LeaveVoiceChat
} else {
leaveText = self.presentationData.strings.VoiceChat_LeaveVoiceChat
}
items.append(ActionSheetButtonItem(title: leaveText, color: .accent, action: { [weak self, weak actionSheet] in
actionSheet?.dismissAnimated()
guard let strongSelf = self else {
return
}
strongSelf.leaveDisposable.set((strongSelf.call.leave(terminateIfPossible: false)
|> deliverOnMainQueue).start(completed: { [weak self] in
self?.controller?.dismiss(closing: true)
}))
}))
actionSheet.setItemGroups([
ActionSheetItemGroup(items: items),
ActionSheetItemGroup(items: [
ActionSheetButtonItem(title: self.presentationData.strings.Common_Cancel, color: .accent, font: .bold, action: { [weak actionSheet] in
actionSheet?.dismissAnimated()
})
])
])
self.controller?.present(actionSheet, in: .window(.root))
} else {
self.leaveDisposable.set((self.call.leave(terminateIfPossible: false)
|> deliverOnMainQueue).start(completed: { [weak self] in
self?.controller?.dismiss(closing: true)
}))
}
}
@objc func dimTapGesture(_ recognizer: UITapGestureRecognizer) {
if case .ended = recognizer.state {
if self.isScheduling {
self.dismissScheduled()
} else {
self.controller?.dismiss(closing: false)
self.controller?.dismissAllTooltips()
}
}
}
private func presentUndoOverlay(content: UndoOverlayContent, action: @escaping (UndoOverlayAction) -> Bool) {
var animateInAsReplacement = false
self.controller?.forEachController { c in
if let c = c as? UndoOverlayController {
animateInAsReplacement = true
c.dismiss()
}
return true
}
self.controller?.present(UndoOverlayController(presentationData: self.presentationData, content: content, elevatedLayout: false, animateInAsReplacement: animateInAsReplacement, action: action), in: .current)
}
private func presentShare(_ inviteLinks: GroupCallInviteLinks) {
let formatSendTitle: (String) -> String = { string in
var string = string
if string.contains("[") && string.contains("]") {
if let startIndex = string.firstIndex(of: "["), let endIndex = string.firstIndex(of: "]") {
string.removeSubrange(startIndex ... endIndex)
}
} else {
string = string.trimmingCharacters(in: CharacterSet(charactersIn: "0123456789-,."))
}
return string
}
let _ = (self.context.account.postbox.loadedPeerWithId(self.call.peerId)
|> deliverOnMainQueue).start(next: { [weak self] peer in
if let strongSelf = self {
var inviteLinks = inviteLinks
if let peer = peer as? TelegramChannel, case .group = peer.info, !peer.flags.contains(.isGigagroup), !(peer.addressName ?? "").isEmpty, let callState = strongSelf.callState, let defaultParticipantMuteState = callState.defaultParticipantMuteState {
let isMuted = defaultParticipantMuteState == .muted
if !isMuted {
inviteLinks = GroupCallInviteLinks(listenerLink: inviteLinks.listenerLink, speakerLink: nil)
}
}
let presentationData = strongSelf.presentationData
var segmentedValues: [ShareControllerSegmentedValue]?
if let speakerLink = inviteLinks.speakerLink {
segmentedValues = [ShareControllerSegmentedValue(title: presentationData.strings.VoiceChat_InviteLink_Speaker, subject: .url(speakerLink), actionTitle: presentationData.strings.VoiceChat_InviteLink_CopySpeakerLink, formatSendTitle: { count in
return formatSendTitle(presentationData.strings.VoiceChat_InviteLink_InviteSpeakers(Int32(count)))
}), ShareControllerSegmentedValue(title: presentationData.strings.VoiceChat_InviteLink_Listener, subject: .url(inviteLinks.listenerLink), actionTitle: presentationData.strings.VoiceChat_InviteLink_CopyListenerLink, formatSendTitle: { count in
return formatSendTitle(presentationData.strings.VoiceChat_InviteLink_InviteListeners(Int32(count)))
})]
}
let shareController = ShareController(context: strongSelf.context, subject: .url(inviteLinks.listenerLink), segmentedValues: segmentedValues, forceTheme: strongSelf.darkTheme, forcedActionTitle: presentationData.strings.VoiceChat_CopyInviteLink)
shareController.completed = { [weak self] peerIds in
if let strongSelf = self {
let _ = (strongSelf.context.engine.data.get(
EngineDataList(
peerIds.map(TelegramEngine.EngineData.Item.Peer.Peer.init)
)
)
|> deliverOnMainQueue).start(next: { [weak self] peerList in
if let strongSelf = self {
let peers = peerList.compactMap { $0 }
let presentationData = strongSelf.context.sharedContext.currentPresentationData.with { $0 }
let text: String
var isSavedMessages = false
if peers.count == 1, let peer = peers.first {
isSavedMessages = peer.id == strongSelf.context.account.peerId
let peerName = peer.id == strongSelf.context.account.peerId ? presentationData.strings.DialogList_SavedMessages : peer.displayTitle(strings: presentationData.strings, displayOrder: presentationData.nameDisplayOrder)
text = presentationData.strings.VoiceChat_ForwardTooltip_Chat(peerName).string
} else if peers.count == 2, let firstPeer = peers.first, let secondPeer = peers.last {
let firstPeerName = firstPeer.id == strongSelf.context.account.peerId ? presentationData.strings.DialogList_SavedMessages : firstPeer.displayTitle(strings: presentationData.strings, displayOrder: presentationData.nameDisplayOrder)
let secondPeerName = secondPeer.id == strongSelf.context.account.peerId ? presentationData.strings.DialogList_SavedMessages : secondPeer.displayTitle(strings: presentationData.strings, displayOrder: presentationData.nameDisplayOrder)
text = presentationData.strings.VoiceChat_ForwardTooltip_TwoChats(firstPeerName, secondPeerName).string
} else if let peer = peers.first {
let peerName = peer.displayTitle(strings: presentationData.strings, displayOrder: presentationData.nameDisplayOrder)
text = presentationData.strings.VoiceChat_ForwardTooltip_ManyChats(peerName, "\(peers.count - 1)").string
} else {
text = ""
}
strongSelf.controller?.present(UndoOverlayController(presentationData: presentationData, content: .forward(savedMessages: isSavedMessages, text: text), elevatedLayout: false, animateInAsReplacement: true, action: { _ in return false }), in: .current)
}
})
}
}
shareController.actionCompleted = { [weak self] in
if let strongSelf = self {
let presentationData = strongSelf.context.sharedContext.currentPresentationData.with { $0 }
strongSelf.controller?.present(UndoOverlayController(presentationData: presentationData, content: .linkCopied(text: presentationData.strings.VoiceChat_InviteLinkCopiedText), elevatedLayout: false, animateInAsReplacement: false, action: { _ in return false }), in: .window(.root))
}
}
strongSelf.controller?.present(shareController, in: .window(.root))
}
})
}
private var actionButtonPressTimer: SwiftSignalKit.Timer?
private var actionButtonPressedTimestamp: Double?
private func startActionButtonPressTimer() {
self.actionButtonPressTimer?.invalidate()
let pressTimer = SwiftSignalKit.Timer(timeout: 0.185, repeat: false, completion: { [weak self] in
self?.actionButtonPressedTimestamp = CACurrentMediaTime()
self?.actionButtonPressTimerFired()
self?.actionButtonPressTimer = nil
}, queue: Queue.mainQueue())
self.actionButtonPressTimer = pressTimer
pressTimer.start()
}
private func stopActionButtonPressTimer() {
self.actionButtonPressTimer?.invalidate()
self.actionButtonPressTimer = nil
}
private func actionButtonPressTimerFired() {
guard let callState = self.callState else {
return
}
if callState.muteState != nil {
self.pushingToTalk = true
self.call.setIsMuted(action: .muted(isPushToTalkActive: true))
}
if let (layout, navigationHeight) = self.validLayout {
self.containerLayoutUpdated(layout, navigationHeight: navigationHeight, transition: .animated(duration: 0.3, curve: .spring))
}
self.updateMembers()
}
@objc private func actionButtonPressGesture(_ gestureRecognizer: UILongPressGestureRecognizer) {
guard let callState = self.callState else {
return
}
if case .connecting = callState.networkState, callState.scheduleTimestamp == nil && !self.isScheduling {
return
}
if callState.scheduleTimestamp != nil || self.isScheduling {
switch gestureRecognizer.state {
case .began:
self.actionButton.pressing = true
self.hapticFeedback.impact(.light)
case .ended, .cancelled:
self.actionButton.pressing = false
let location = gestureRecognizer.location(in: self.actionButton.view)
if self.actionButton.hitTest(location, with: nil) != nil {
if self.isScheduling {
self.schedule()
} else if callState.canManageCall {
self.call.startScheduled()
} else {
if !callState.subscribedToScheduled {
let location = self.actionButton.view.convert(self.actionButton.bounds, to: self.view).center
let point = CGRect(origin: CGPoint(x: location.x - 5.0, y: location.y - 5.0 - 68.0), size: CGSize(width: 10.0, height: 10.0))
self.controller?.present(TooltipScreen(account: self.context.account, sharedContext: self.context.sharedContext, text: .plain(text: self.presentationData.strings.VoiceChat_ReminderNotify), style: .gradient(UIColor(rgb: 0x262c5a), UIColor(rgb: 0x5d2835)), icon: nil, location: .point(point, .bottom), displayDuration: .custom(3.0), shouldDismissOnTouch: { _, _ in
return .dismiss(consume: false)
}), in: .window(.root))
}
self.call.toggleScheduledSubscription(!callState.subscribedToScheduled)
}
}
default:
break
}
return
}
if let muteState = callState.muteState {
if !muteState.canUnmute {
switch gestureRecognizer.state {
case .began:
self.actionButton.pressing = true
self.hapticFeedback.impact(.light)
case .ended, .cancelled:
self.actionButton.pressing = false
let location = gestureRecognizer.location(in: self.actionButton.view)
if self.actionButton.hitTest(location, with: nil) != nil {
self.call.raiseHand()
self.actionButton.playAnimation()
}
default:
break
}
return
}
}
switch gestureRecognizer.state {
case .began:
self.actionButton.pressing = true
self.hapticFeedback.impact(.light)
self.actionButtonPressedTimestamp = nil
self.startActionButtonPressTimer()
if let (layout, navigationHeight) = self.validLayout {
self.containerLayoutUpdated(layout, navigationHeight: navigationHeight, transition: .animated(duration: 0.3, curve: .spring))
}
case .ended, .cancelled:
if self.actionButtonPressTimer != nil {
self.pushingToTalk = false
self.actionButton.pressing = false
self.stopActionButtonPressTimer()
self.call.toggleIsMuted()
} else {
self.hapticFeedback.impact(.light)
if self.pushingToTalk, let timestamp = self.actionButtonPressedTimestamp, CACurrentMediaTime() < timestamp + 0.5 {
self.pushingToTalk = false
self.temporaryPushingToTalk = true
self.call.setIsMuted(action: .unmuted)
Queue.mainQueue().after(0.1) {
self.temporaryPushingToTalk = false
self.actionButton.pressing = false
if let (layout, navigationHeight) = self.validLayout {
self.containerLayoutUpdated(layout, navigationHeight: navigationHeight, transition: .animated(duration: 0.3, curve: .spring))
}
}
} else {
self.pushingToTalk = false
self.actionButton.pressing = false
self.call.setIsMuted(action: .muted(isPushToTalkActive: false))
}
}
if let callState = self.callState {
self.itemInteraction?.updateAudioLevels([(callState.myPeerId, 0, 0.0, false)], reset: true)
}
if let (layout, navigationHeight) = self.validLayout {
self.containerLayoutUpdated(layout, navigationHeight: navigationHeight, transition: .animated(duration: 0.3, curve: .spring))
}
self.updateMembers()
default:
break
}
}
@objc private func actionPressed() {
if self.isScheduling {
self.schedule()
}
}
@objc private func audioPressed() {
self.hapticFeedback.impact(.light)
if let _ = self.callState?.scheduleTimestamp {
if let callState = self.callState, let peer = self.peer, !callState.canManageCall && (peer.addressName?.isEmpty ?? true) {
return
}
let _ = (self.inviteLinksPromise.get()
|> take(1)
|> deliverOnMainQueue).start(next: { [weak self] inviteLinks in
guard let strongSelf = self else {
return
}
let _ = (strongSelf.context.engine.data.get(
TelegramEngine.EngineData.Item.Peer.Peer(id: strongSelf.call.peerId),
TelegramEngine.EngineData.Item.Peer.ExportedInvitation(id: strongSelf.call.peerId)
)
|> map { peer, exportedInvitation -> GroupCallInviteLinks? in
if let inviteLinks = inviteLinks {
return inviteLinks
} else if let peer = peer, let addressName = peer.addressName, !addressName.isEmpty {
return GroupCallInviteLinks(listenerLink: "https://t.me/\(addressName)?voicechat", speakerLink: nil)
} else if let link = exportedInvitation?.link {
return GroupCallInviteLinks(listenerLink: link, speakerLink: nil)
}
return nil
}
|> deliverOnMainQueue).start(next: { links in
guard let strongSelf = self else {
return
}
if let links = links {
strongSelf.presentShare(links)
}
})
})
return
}
guard let (availableOutputs, currentOutput) = self.audioOutputState else {
return
}
guard availableOutputs.count >= 2 else {
return
}
if availableOutputs.count == 2 {
for output in availableOutputs {
if output != currentOutput {
self.call.setCurrentAudioOutput(output)
break
}
}
} else {
let actionSheet = ActionSheetController(presentationData: self.presentationData.withUpdated(theme: self.darkTheme))
var items: [ActionSheetItem] = []
for output in availableOutputs {
let title: String
var icon: UIImage?
switch output {
case .builtin:
title = UIDevice.current.model
case .speaker:
title = self.presentationData.strings.Call_AudioRouteSpeaker
icon = generateScaledImage(image: UIImage(bundleImageName: "Call/CallSpeakerButton"), size: CGSize(width: 48.0, height: 48.0), opaque: false)
case .headphones:
title = self.presentationData.strings.Call_AudioRouteHeadphones
case let .port(port):
title = port.name
if port.type == .bluetooth {
var image = UIImage(bundleImageName: "Call/CallBluetoothButton")
let portName = port.name.lowercased()
if portName.contains("airpods max") {
image = UIImage(bundleImageName: "Call/CallAirpodsMaxButton")
} else if portName.contains("airpods pro") {
image = UIImage(bundleImageName: "Call/CallAirpodsProButton")
} else if portName.contains("airpods") {
image = UIImage(bundleImageName: "Call/CallAirpodsButton")
}
icon = generateScaledImage(image: image, size: CGSize(width: 48.0, height: 48.0), opaque: false)
}
}
items.append(CallRouteActionSheetItem(title: title, icon: icon, selected: output == currentOutput, action: { [weak self, weak actionSheet] in
actionSheet?.dismissAnimated()
self?.call.setCurrentAudioOutput(output)
}))
}
actionSheet.setItemGroups([ActionSheetItemGroup(items: items), ActionSheetItemGroup(items: [
ActionSheetButtonItem(title: self.presentationData.strings.Call_AudioRouteHide, color: .accent, font: .bold, action: { [weak actionSheet] in
actionSheet?.dismissAnimated()
})
])
])
self.controller?.present(actionSheet, in: .window(.calls))
}
}
@objc private func cameraPressed() {
self.hapticFeedback.impact(.light)
if self.call.hasVideo {
self.call.disableVideo()
if let (layout, navigationHeight) = self.validLayout {
self.animatingButtonsSwap = true
self.containerLayoutUpdated(layout, navigationHeight: navigationHeight, transition: .animated(duration: 0.4, curve: .spring))
}
} else {
DeviceAccess.authorizeAccess(to: .camera(.videoCall), onlyCheck: true, presentationData: self.presentationData.withUpdated(theme: self.darkTheme), present: { [weak self] c, a in
self?.controller?.present(c, in: .window(.root), with: a)
}, openSettings: { [weak self] in
self?.context.sharedContext.applicationBindings.openSettings()
}, _: { [weak self] ready in
guard let strongSelf = self, ready else {
return
}
var isFrontCamera = true
let videoCapturer = OngoingCallVideoCapturer()
let input = videoCapturer.video()
if let videoView = strongSelf.videoRenderingContext.makeView(input: input, blur: false) {
videoView.updateIsEnabled(true)
let cameraNode = GroupVideoNode(videoView: videoView, backdropVideoView: nil)
let controller = VoiceChatCameraPreviewController(sharedContext: strongSelf.context.sharedContext, cameraNode: cameraNode, shareCamera: { [weak self] _, unmuted in
if let strongSelf = self {
strongSelf.call.setIsMuted(action: unmuted ? .unmuted : .muted(isPushToTalkActive: false))
(strongSelf.call as! PresentationGroupCallImpl).requestVideo(capturer: videoCapturer, useFrontCamera: isFrontCamera)
if let (layout, navigationHeight) = strongSelf.validLayout {
strongSelf.animatingButtonsSwap = true
strongSelf.containerLayoutUpdated(layout, navigationHeight: navigationHeight, transition: .animated(duration: 0.4, curve: .spring))
}
}
}, switchCamera: {
Queue.mainQueue().after(0.1) {
isFrontCamera = !isFrontCamera
videoCapturer.switchVideoInput(isFront: isFrontCamera)
}
})
strongSelf.controller?.present(controller, in: .window(.root))
}
})
}
}
@objc private func switchCameraPressed() {
self.hapticFeedback.impact(.light)
Queue.mainQueue().after(0.1) {
self.call.switchVideoCamera()
}
if let callState = self.callState {
for entry in self.currentFullscreenEntries {
if case let .peer(peerEntry, _) = entry {
if peerEntry.peer.id == callState.myPeerId {
if let videoEndpointId = peerEntry.videoEndpointId, let videoNode = self.videoNodes[videoEndpointId] {
videoNode.flip(withBackground: false)
}
break
}
}
}
}
self.mainStageNode.flipVideoIfNeeded()
let springDuration: Double = 0.7
let springDamping: CGFloat = 100.0
self.switchCameraButton.isUserInteractionEnabled = false
self.switchCameraButton.layer.animateSpring(from: 0.0 as NSNumber, to: CGFloat.pi as NSNumber, keyPath: "transform.rotation.z", duration: springDuration, damping: springDamping, completion: { [weak self] _ in
self?.switchCameraButton.isUserInteractionEnabled = true
})
}
private var isLandscape: Bool {
if let (layout, _) = self.validLayout, layout.size.width > layout.size.height, case .compact = layout.metrics.widthClass {
return true
} else {
return false
}
}
private var effectiveBottomAreaHeight: CGFloat {
if let (layout, _) = self.validLayout, case .regular = layout.metrics.widthClass {
return bottomAreaHeight
}
switch self.displayMode {
case .modal:
return bottomAreaHeight
case let .fullscreen(controlsHidden):
return controlsHidden ? 0.0 : fullscreenBottomAreaHeight
}
}
private var isFullscreen: Bool {
switch self.displayMode {
case .fullscreen(_), .modal(_, true):
return true
default:
return false
}
}
private func updateDecorationsLayout(transition: ContainedViewLayoutTransition, completion: (() -> Void)? = nil) {
guard let (layout, _) = self.validLayout else {
return
}
let isLandscape = self.isLandscape
let layoutTopInset: CGFloat = max(layout.statusBarHeight ?? 0.0, layout.safeInsets.top)
let listTopInset = isLandscape ? topPanelHeight : layoutTopInset + topPanelHeight
let bottomPanelHeight = isLandscape ? layout.intrinsicInsets.bottom : bottomAreaHeight + layout.intrinsicInsets.bottom
let size = layout.size
let contentWidth: CGFloat
var contentLeftInset: CGFloat = 0.0
var forceUpdate = false
if case .regular = layout.metrics.widthClass {
contentWidth = max(320.0, min(375.0, floor(size.width * 0.3)))
if self.peerIdToEndpointId.isEmpty {
contentLeftInset = 0.0
} else {
contentLeftInset = self.panelHidden ? layout.size.width : layout.size.width - contentWidth
}
forceUpdate = true
} else {
contentWidth = isLandscape ? min(530.0, size.width - 210.0) : size.width
}
let listSize = CGSize(width: contentWidth, height: layout.size.height - listTopInset - bottomPanelHeight + bottomGradientHeight)
let topInset: CGFloat
if let (panInitialTopInset, panOffset) = self.panGestureArguments {
if self.isExpanded {
topInset = min(self.topInset ?? listSize.height, panInitialTopInset + max(0.0, panOffset))
} else {
topInset = max(0.0, panInitialTopInset + min(0.0, panOffset))
}
} else if case .regular = layout.metrics.widthClass {
topInset = 0.0
} else if let currentTopInset = self.topInset {
topInset = self.isExpanded ? 0.0 : currentTopInset
} else {
topInset = listSize.height - 46.0 - floor(56.0 * 3.5)
}
var bottomEdge: CGFloat = 0.0
if case .regular = layout.metrics.widthClass {
bottomEdge = size.height
} else {
self.listNode.forEachItemNode { itemNode in
if let itemNode = itemNode as? ListViewItemNode {
let convertedFrame = self.listNode.view.convert(itemNode.frame, to: self.contentContainer.view)
if convertedFrame.maxY > bottomEdge {
bottomEdge = convertedFrame.maxY
}
}
}
if bottomEdge.isZero {
bottomEdge = self.listNode.frame.minY + 46.0 + 56.0
}
}
let rawPanelOffset = topInset + listTopInset - topPanelHeight
let panelOffset = max(layoutTopInset, rawPanelOffset)
let topPanelFrame: CGRect
if isLandscape {
topPanelFrame = CGRect(origin: CGPoint(x: 0.0, y: 0.0), size: CGSize(width: size.width, height: topPanelHeight))
} else {
topPanelFrame = CGRect(origin: CGPoint(x: 0.0, y: panelOffset), size: CGSize(width: size.width, height: topPanelHeight))
}
let sideInset: CGFloat = 14.0
let bottomPanelCoverHeight = bottomAreaHeight + layout.intrinsicInsets.bottom
var bottomGradientFrame = CGRect(origin: CGPoint(x: 0.0, y: layout.size.height - bottomPanelCoverHeight), size: CGSize(width: size.width, height: bottomGradientHeight))
if isLandscape {
bottomGradientFrame.origin.y = layout.size.height
}
let transitionContainerFrame = CGRect(x: 0.0, y: 0.0, width: layout.size.width, height: layout.size.height)
transition.updateFrame(node: self.transitionContainerNode, frame: transitionContainerFrame)
transition.updateFrame(view: self.transitionMaskView, frame: CGRect(x: 0.0, y: 0.0, width: transitionContainerFrame.width, height: transitionContainerFrame.height))
let updateMaskLayers = {
var topPanelFrame = topPanelFrame
if self.animatingContextMenu {
topPanelFrame.origin.y = 0.0
}
transition.updateFrame(layer: self.transitionMaskTopFillLayer, frame: CGRect(x: 0.0, y: 0.0, width: transitionContainerFrame.width, height: topPanelFrame.maxY))
transition.updateFrame(layer: self.transitionMaskFillLayer, frame: CGRect(x: 0.0, y: topPanelFrame.maxY, width: transitionContainerFrame.width, height: bottomGradientFrame.minY - topPanelFrame.maxY))
transition.updateFrame(layer: self.transitionMaskGradientLayer, frame: CGRect(x: 0.0, y: bottomGradientFrame.minY, width: transitionContainerFrame.width, height: bottomGradientFrame.height))
transition.updateFrame(layer: self.transitionMaskBottomFillLayer, frame: CGRect(x: 0.0, y: bottomGradientFrame.minY, width: transitionContainerFrame.width, height: max(0.0, transitionContainerFrame.height - bottomGradientFrame.minY)))
}
if transition.isAnimated {
updateMaskLayers()
} else {
CATransaction.begin()
CATransaction.setDisableActions(true)
updateMaskLayers()
CATransaction.commit()
}
var bottomInset: CGFloat = 0.0
if case .compact = layout.metrics.widthClass, case let .fullscreen(controlsHidden) = self.displayMode {
if !controlsHidden {
bottomInset = 80.0
}
}
transition.updateAlpha(node: self.bottomGradientNode, alpha: self.isLandscape ? 0.0 : 1.0)
var isTablet = false
let videoFrame: CGRect
let videoContainerFrame: CGRect
if case .regular = layout.metrics.widthClass {
isTablet = true
let videoTopEdgeY = topPanelFrame.maxY
let videoBottomEdgeY = layout.size.height - layout.intrinsicInsets.bottom
videoFrame = CGRect(x: sideInset, y: 0.0, width: contentLeftInset - sideInset, height: videoBottomEdgeY - videoTopEdgeY)
videoContainerFrame = CGRect(origin: CGPoint(x: 0.0, y: videoTopEdgeY), size: CGSize(width: contentLeftInset, height: layout.size.height))
} else {
let videoTopEdgeY = isLandscape ? 0.0 : layoutTopInset
let videoBottomEdgeY = self.isLandscape ? layout.size.height : layout.size.height - layout.intrinsicInsets.bottom - 92.0
videoFrame = CGRect(x: 0.0, y: videoTopEdgeY, width: isLandscape ? max(0.0, layout.size.width - layout.safeInsets.right - 92.0) : layout.size.width, height: videoBottomEdgeY - videoTopEdgeY)
videoContainerFrame = CGRect(origin: CGPoint(), size: layout.size)
}
transition.updateFrame(node: self.mainStageContainerNode, frame: videoContainerFrame)
transition.updateFrame(node: self.mainStageBackgroundNode, frame: videoFrame)
if !self.mainStageNode.animating {
transition.updateFrame(node: self.mainStageNode, frame: videoFrame)
}
self.mainStageNode.update(size: videoFrame.size, sideInset: layout.safeInsets.left, bottomInset: self.isLandscape ? 0.0 : bottomInset, isLandscape: videoFrame.width > videoFrame.height, isTablet: isTablet, transition: transition)
let backgroundFrame = CGRect(origin: CGPoint(x: 0.0, y: topPanelFrame.maxY), size: CGSize(width: size.width, height: layout.size.height))
let leftBorderFrame: CGRect
let rightBorderFrame: CGRect
let additionalInset: CGFloat = 60.0
let additionalSideInset = (size.width - contentWidth) / 2.0
let additionalLeftInset = size.width / 2.0
if isLandscape {
leftBorderFrame = CGRect(origin: CGPoint(x: 0.0, y: topPanelFrame.maxY - additionalInset), size: CGSize(width: (size.width - contentWidth) / 2.0 + sideInset, height: layout.size.height))
rightBorderFrame = CGRect(origin: CGPoint(x: size.width - (size.width - contentWidth) / 2.0 - sideInset, y: topPanelFrame.maxY - additionalInset), size: CGSize(width: layout.safeInsets.right + (size.width - contentWidth) / 2.0 + sideInset, height: layout.size.height))
} else {
var isFullscreen = false
if case .fullscreen = self.displayMode {
isFullscreen = true
forceUpdate = true
}
leftBorderFrame = CGRect(origin: CGPoint(x: -additionalInset - additionalLeftInset, y: topPanelFrame.maxY - additionalInset * (isFullscreen ? 0.95 : 0.8)), size: CGSize(width: sideInset + additionalInset + additionalLeftInset + (contentLeftInset.isZero ? additionalSideInset : contentLeftInset), height: layout.size.height))
rightBorderFrame = CGRect(origin: CGPoint(x: size.width - sideInset - (contentLeftInset.isZero ? additionalSideInset : 0.0), y: topPanelFrame.maxY - additionalInset * (isFullscreen ? 0.95 : 0.8)), size: CGSize(width: sideInset + additionalInset + additionalLeftInset + additionalSideInset, height: layout.size.height))
}
let topCornersFrame = CGRect(x: sideInset + (contentLeftInset.isZero ? floorToScreenPixels((size.width - contentWidth) / 2.0) : contentLeftInset), y: topPanelFrame.maxY - 60.0, width: contentWidth - sideInset * 2.0, height: 50.0 + 60.0)
let previousTopPanelFrame = self.topPanelNode.frame
let previousBackgroundFrame = self.backgroundNode.frame
let previousLeftBorderFrame = self.leftBorderNode.frame
let previousRightBorderFrame = self.rightBorderNode.frame
if !topPanelFrame.equalTo(previousTopPanelFrame) || forceUpdate {
if topPanelFrame.width != previousTopPanelFrame.width {
transition.updateFrame(node: self.topPanelNode, frame: topPanelFrame)
transition.updateFrame(node: self.topCornersNode, frame: topCornersFrame)
transition.updateFrame(node: self.backgroundNode, frame: backgroundFrame)
transition.updateFrame(node: self.leftBorderNode, frame: leftBorderFrame)
transition.updateFrame(node: self.rightBorderNode, frame: rightBorderFrame)
} else {
self.topPanelNode.frame = topPanelFrame
let positionDelta = CGPoint(x: 0.0, y: topPanelFrame.minY - previousTopPanelFrame.minY)
transition.animateOffsetAdditive(layer: self.topPanelNode.layer, offset: positionDelta.y, completion: completion)
transition.updateFrame(node: self.topCornersNode, frame: topCornersFrame)
self.backgroundNode.frame = backgroundFrame
let backgroundPositionDelta = CGPoint(x: 0.0, y: previousBackgroundFrame.minY - backgroundFrame.minY)
transition.animatePositionAdditive(node: self.backgroundNode, offset: backgroundPositionDelta)
self.leftBorderNode.frame = leftBorderFrame
let leftBorderPositionDelta = CGPoint(x: previousLeftBorderFrame.maxX - leftBorderFrame.maxX, y: previousLeftBorderFrame.minY - leftBorderFrame.minY)
transition.animatePositionAdditive(node: self.leftBorderNode, offset: leftBorderPositionDelta)
self.rightBorderNode.frame = rightBorderFrame
let rightBorderPositionDelta = CGPoint(x: previousRightBorderFrame.minX - rightBorderFrame.minX, y: previousRightBorderFrame.minY - rightBorderFrame.minY)
transition.animatePositionAdditive(node: self.rightBorderNode, offset: rightBorderPositionDelta)
}
} else {
completion?()
}
self.topPanelBackgroundNode.frame = CGRect(x: 0.0, y: topPanelHeight - 24.0, width: size.width, height: min(topPanelFrame.height, 24.0))
let listMaxY = listTopInset + listSize.height
let bottomOffset = min(0.0, bottomEdge - listMaxY) + layout.size.height - bottomPanelHeight
let bottomCornersFrame = CGRect(origin: CGPoint(x: sideInset + floorToScreenPixels((size.width - contentWidth) / 2.0), y: -50.0 + bottomOffset + bottomGradientHeight), size: CGSize(width: contentWidth - sideInset * 2.0, height: 50.0 + 60.0))
let bottomPanelBackgroundFrame = CGRect(x: 0.0, y: bottomOffset + bottomGradientHeight, width: size.width, height: 2000.0)
let previousBottomCornersFrame = self.bottomCornersNode.frame
if !bottomCornersFrame.equalTo(previousBottomCornersFrame) {
if bottomCornersFrame.width != previousBottomCornersFrame.width {
transition.updateFrame(node: self.bottomCornersNode, frame: bottomCornersFrame)
transition.updateFrame(node: self.bottomPanelBackgroundNode, frame: bottomPanelBackgroundFrame)
} else {
self.bottomCornersNode.frame = bottomCornersFrame
self.bottomPanelBackgroundNode.frame = bottomPanelBackgroundFrame
let positionDelta = CGPoint(x: 0.0, y: previousBottomCornersFrame.minY - bottomCornersFrame.minY)
transition.animatePositionAdditive(node: self.bottomCornersNode, offset: positionDelta)
transition.animatePositionAdditive(node: self.bottomPanelBackgroundNode, offset: positionDelta)
}
}
let participantsFrame = CGRect(x: 0.0, y: bottomCornersFrame.maxY - 100.0, width: size.width, height: 216.0)
transition.updateFrame(node: self.participantsNode, frame: participantsFrame)
self.participantsNode.update(size: participantsFrame.size, participants: self.currentTotalCount, groupingSeparator: self.presentationData.dateTimeFormat.groupingSeparator, transition: .immediate)
}
private var decorationsAreDark: Bool?
private var ignoreLayout = false
private func updateDecorationsColors() {
guard let (layout, _) = self.validLayout else {
return
}
let isFullscreen = self.isFullscreen
let effectiveDisplayMode = self.displayMode
self.ignoreLayout = true
self.controller?.statusBar.updateStatusBarStyle(isFullscreen ? .White : .Ignore, animated: true)
self.ignoreLayout = false
let size = layout.size
let topEdgeFrame: CGRect
if isFullscreen {
let offset: CGFloat
if let statusBarHeight = layout.statusBarHeight {
offset = statusBarHeight
} else {
offset = 44.0
}
topEdgeFrame = CGRect(x: 0.0, y: -offset, width: size.width, height: topPanelHeight + offset)
} else {
topEdgeFrame = CGRect(x: 0.0, y: 0.0, width: size.width, height: topPanelHeight)
}
let backgroundColor: UIColor
if case .fullscreen = effectiveDisplayMode {
backgroundColor = isFullscreen ? panelBackgroundColor : secondaryPanelBackgroundColor
} else if self.isScheduling || self.callState?.scheduleTimestamp != nil {
backgroundColor = panelBackgroundColor
} else {
backgroundColor = isFullscreen ? panelBackgroundColor : secondaryPanelBackgroundColor
}
let transition: ContainedViewLayoutTransition = .animated(duration: 0.3, curve: .linear)
transition.updateFrame(node: self.topPanelEdgeNode, frame: topEdgeFrame)
transition.updateCornerRadius(node: self.topPanelEdgeNode, cornerRadius: isFullscreen ? layout.deviceMetrics.screenCornerRadius - 0.5 : 12.0)
transition.updateBackgroundColor(node: self.topPanelBackgroundNode, color: isFullscreen ? fullscreenBackgroundColor : panelBackgroundColor)
transition.updateBackgroundColor(node: self.topPanelEdgeNode, color: isFullscreen ? fullscreenBackgroundColor : panelBackgroundColor)
transition.updateBackgroundColor(node: self.backgroundNode, color: backgroundColor)
transition.updateBackgroundColor(node: self.bottomPanelBackgroundNode, color: isFullscreen ? fullscreenBackgroundColor : panelBackgroundColor)
transition.updateBackgroundColor(node: self.leftBorderNode, color: isFullscreen ? fullscreenBackgroundColor : panelBackgroundColor)
transition.updateBackgroundColor(node: self.rightBorderNode, color: isFullscreen ? fullscreenBackgroundColor : panelBackgroundColor)
var gridNode: VoiceChatTilesGridItemNode?
self.listNode.forEachItemNode { itemNode in
if let itemNode = itemNode as? VoiceChatTilesGridItemNode {
gridNode = itemNode
}
}
if let gridNode = gridNode {
transition.updateBackgroundColor(node: gridNode.backgroundNode, color: isFullscreen ? fullscreenBackgroundColor : panelBackgroundColor)
}
let previousDark = self.decorationsAreDark
self.decorationsAreDark = isFullscreen
if previousDark != self.decorationsAreDark {
if let snapshotView = self.topCornersNode.view.snapshotContentTree() {
snapshotView.frame = self.topCornersNode.bounds
self.topCornersNode.view.addSubview(snapshotView)
snapshotView.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.3, timingFunction: CAMediaTimingFunctionName.linear.rawValue, removeOnCompletion: false, completion: { [weak snapshotView] _ in
snapshotView?.removeFromSuperview()
})
}
self.topCornersNode.image = decorationTopCornersImage(dark: isFullscreen)
if let snapshotView = self.bottomCornersNode.view.snapshotContentTree() {
snapshotView.frame = self.bottomCornersNode.bounds
self.bottomCornersNode.view.addSubview(snapshotView)
snapshotView.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.3, timingFunction: CAMediaTimingFunctionName.linear.rawValue, removeOnCompletion: false, completion: { [weak snapshotView] _ in
snapshotView?.removeFromSuperview()
})
}
self.bottomCornersNode.image = decorationBottomCornersImage(dark: isFullscreen)
if let gridNode = gridNode {
if let snapshotView = gridNode.cornersNode.view.snapshotContentTree() {
snapshotView.frame = gridNode.cornersNode.bounds
gridNode.cornersNode.view.addSubview(snapshotView)
snapshotView.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.3, timingFunction: CAMediaTimingFunctionName.linear.rawValue, removeOnCompletion: false, completion: { [weak snapshotView] _ in
snapshotView?.removeFromSuperview()
})
}
gridNode.cornersNode.image = decorationCornersImage(top: true, bottom: false, dark: isFullscreen)
gridNode.supernode?.addSubnode(gridNode)
}
UIView.transition(with: self.bottomGradientNode.view, duration: 0.3, options: [.transitionCrossDissolve, .curveLinear]) {
self.bottomGradientNode.backgroundColor = decorationBottomGradientImage(dark: isFullscreen).flatMap { UIColor(patternImage: $0) }
} completion: { _ in
}
self.closeButton.setContent(.image(closeButtonImage(dark: isFullscreen)), animated: transition.isAnimated)
self.optionsButton.setContent(.more(optionsCircleImage(dark: isFullscreen)), animated: transition.isAnimated)
self.panelButton.setContent(.image(panelButtonImage(dark: isFullscreen)), animated: transition.isAnimated)
}
self.updateTitle(transition: transition)
}
private func updateTitle(slide: Bool = false, transition: ContainedViewLayoutTransition) {
guard let _ = self.validLayout else {
return
}
var title = self.currentTitle
if self.isScheduling {
if let peer = self.peer as? TelegramChannel, case .broadcast = peer.info {
title = self.presentationData.strings.ScheduleLiveStream_Title
} else {
title = self.presentationData.strings.ScheduleVoiceChat_Title
}
} else if case .modal(_, false) = self.displayMode, !self.currentTitleIsCustom {
if let navigationController = self.controller?.navigationController as? NavigationController {
for controller in navigationController.viewControllers.reversed() {
if let controller = controller as? ChatController, case let .peer(peerId) = controller.chatLocation, peerId == self.call.peerId {
if let peer = self.peer as? TelegramChannel, case .broadcast = peer.info {
title = self.presentationData.strings.VoiceChatChannel_Title
} else {
title = self.presentationData.strings.VoiceChat_Title
}
}
}
}
}
var subtitle = ""
var speaking = false
if self.scrollAtTop {
subtitle = self.currentSubtitle
speaking = false
} else {
subtitle = self.currentSpeakingSubtitle ?? self.currentSubtitle
speaking = self.currentSpeakingSubtitle != nil
}
if self.isScheduling {
subtitle = ""
speaking = false
} else if self.callState?.scheduleTimestamp != nil {
if self.callState?.canManageCall ?? false {
subtitle = self.presentationData.strings.VoiceChat_TapToEditTitle
} else {
subtitle = self.presentationData.strings.VoiceChat_Scheduled
}
speaking = false
}
self.titleNode.update(size: CGSize(width: self.titleNode.bounds.width, height: 44.0), title: title, subtitle: subtitle, speaking: speaking, slide: slide, transition: transition)
}
private func updateButtons(transition: ContainedViewLayoutTransition) {
guard let (layout, _) = self.validLayout else {
return
}
var audioMode: CallControllerButtonsSpeakerMode = .none
//var hasAudioRouteMenu: Bool = false
if let (availableOutputs, maybeCurrentOutput) = self.audioOutputState, let currentOutput = maybeCurrentOutput {
//hasAudioRouteMenu = availableOutputs.count > 2
switch currentOutput {
case .builtin:
audioMode = .builtin
case .speaker:
audioMode = .speaker
case .headphones:
audioMode = .headphones
case let .port(port):
var type: CallControllerButtonsSpeakerMode.BluetoothType = .generic
let portName = port.name.lowercased()
if portName.contains("airpods max") {
type = .airpodsMax
} else if portName.contains("airpods pro") {
type = .airpodsPro
} else if portName.contains("airpods") {
type = .airpods
}
audioMode = .bluetooth(type)
}
if availableOutputs.count <= 1 {
audioMode = .none
}
}
let normalButtonAppearance: CallControllerButtonItemNode.Content.Appearance
let activeButtonAppearance: CallControllerButtonItemNode.Content.Appearance
if let color = self.currentNormalButtonColor {
normalButtonAppearance = .color(.custom(color.rgb, 1.0))
} else {
normalButtonAppearance = .color(.custom(self.isFullscreen ? 0x1c1c1e : 0x2c2c2e, 1.0))
}
if let color = self.currentActiveButtonColor {
activeButtonAppearance = .color(.custom(color.rgb, 1.0))
} else {
activeButtonAppearance = .color(.custom(self.isFullscreen ? 0x1c1c1e : 0x2c2c2e, 1.0))
}
var soundImage: CallControllerButtonItemNode.Content.Image
var soundAppearance: CallControllerButtonItemNode.Content.Appearance = normalButtonAppearance
var soundTitle: String = self.presentationData.strings.Call_Speaker
switch audioMode {
case .none, .builtin:
soundImage = .speaker
case .speaker:
soundImage = .speaker
soundAppearance = activeButtonAppearance
case .headphones:
soundImage = .headphones
soundTitle = self.presentationData.strings.Call_Audio
case let .bluetooth(type):
switch type {
case .generic:
soundImage = .bluetooth
case .airpods:
soundImage = .airpods
case .airpodsPro:
soundImage = .airpodsPro
case .airpodsMax:
soundImage = .airpodsMax
}
soundTitle = self.presentationData.strings.Call_Audio
}
let isScheduled = self.isScheduling || self.callState?.scheduleTimestamp != nil
var isSoundEnabled = true
if isScheduled {
if let callState = self.callState, let peer = self.peer, !callState.canManageCall && (peer.addressName?.isEmpty ?? true) {
isSoundEnabled = false
} else {
soundImage = .share
soundTitle = self.presentationData.strings.VoiceChat_ShareShort
soundAppearance = normalButtonAppearance
}
}
let audioButtonSize: CGSize
var buttonsTitleAlpha: CGFloat
let effectiveDisplayMode = self.displayMode
let hasCameraButton = self.cameraButton.isUserInteractionEnabled
let hasVideo = self.call.hasVideo
switch effectiveDisplayMode {
case .modal:
audioButtonSize = hasCameraButton ? smallButtonSize : sideButtonSize
buttonsTitleAlpha = 1.0
case .fullscreen:
if case .regular = layout.metrics.widthClass {
audioButtonSize = hasCameraButton ? smallButtonSize : sideButtonSize
} else {
audioButtonSize = sideButtonSize
}
if case .regular = layout.metrics.widthClass {
buttonsTitleAlpha = 1.0
} else {
buttonsTitleAlpha = 0.0
}
}
self.cameraButton.update(size: sideButtonSize, content: CallControllerButtonItemNode.Content(appearance: hasVideo ? activeButtonAppearance : normalButtonAppearance, image: hasVideo ? .cameraOn : .cameraOff), text: self.presentationData.strings.VoiceChat_Video, transition: transition)
self.switchCameraButton.update(size: audioButtonSize, content: CallControllerButtonItemNode.Content(appearance: normalButtonAppearance, image: .flipCamera), text: "", transition: transition)
transition.updateAlpha(node: self.switchCameraButton, alpha: hasCameraButton && hasVideo ? 1.0 : 0.0)
transition.updateTransformScale(node: self.switchCameraButton, scale: hasCameraButton && hasVideo ? 1.0 : 0.0)
transition.updateTransformScale(node: self.cameraButton, scale: hasCameraButton ? 1.0 : 0.0)
let hasAudioButton = !self.isScheduling
transition.updateAlpha(node: self.audioButton, alpha: hasCameraButton || !hasAudioButton ? 0.0 : 1.0)
transition.updateTransformScale(node: self.audioButton, scale: hasCameraButton || !hasAudioButton ? 0.0 : 1.0)
self.audioButton.update(size: audioButtonSize, content: CallControllerButtonItemNode.Content(appearance: soundAppearance, image: soundImage, isEnabled: isSoundEnabled), text: soundTitle, transition: transition)
self.audioButton.isUserInteractionEnabled = isSoundEnabled
self.leaveButton.update(size: sideButtonSize, content: CallControllerButtonItemNode.Content(appearance: .color(.custom(0xff3b30, 0.3)), image: .cancel), text: self.presentationData.strings.VoiceChat_Leave, transition: .immediate)
transition.updateAlpha(node: self.cameraButton.textNode, alpha: buttonsTitleAlpha)
transition.updateAlpha(node: self.switchCameraButton.textNode, alpha: buttonsTitleAlpha)
transition.updateAlpha(node: self.audioButton.textNode, alpha: buttonsTitleAlpha)
transition.updateAlpha(node: self.leaveButton.textNode, alpha: buttonsTitleAlpha)
}
func containerLayoutUpdated(_ layout: ContainerViewLayout, navigationHeight: CGFloat, transition: ContainedViewLayoutTransition) {
guard !self.ignoreLayout else {
return
}
let isFirstTime = self.validLayout == nil
let previousLayout = self.validLayout?.0
self.validLayout = (layout, navigationHeight)
let size = layout.size
let contentWidth: CGFloat
let headerWidth: CGFloat
let contentLeftInset: CGFloat
if case .regular = layout.metrics.widthClass {
contentWidth = max(320.0, min(375.0, floor(size.width * 0.3)))
headerWidth = size.width
if self.peerIdToEndpointId.isEmpty {
contentLeftInset = 0.0
} else {
contentLeftInset = self.panelHidden ? layout.size.width : layout.size.width - contentWidth
}
} else {
contentWidth = self.isLandscape ? min(530.0, size.width - 210.0) : size.width
headerWidth = contentWidth
contentLeftInset = 0.0
}
var previousIsLandscape = false
if let previousLayout = previousLayout, case .compact = previousLayout.metrics.widthClass, previousLayout.size.width > previousLayout.size.height {
previousIsLandscape = true
}
var shouldSwitchToExpanded = false
if case let .modal(isExpanded, _) = self.displayMode {
if previousIsLandscape != self.isLandscape && !isExpanded {
shouldSwitchToExpanded = true
} else if case .regular = layout.metrics.widthClass, !isExpanded {
shouldSwitchToExpanded = true
}
}
if shouldSwitchToExpanded {
self.displayMode = .modal(isExpanded: true, isFilled: true)
self.updateDecorationsColors()
self.updateDecorationsLayout(transition: transition)
self.updateMembers()
} else if case .fullscreen = self.displayMode, previousIsLandscape != self.isLandscape {
self.updateMembers()
}
let effectiveDisplayMode = self.displayMode
transition.updateFrame(node: self.titleNode, frame: CGRect(origin: CGPoint(x: floorToScreenPixels((size.width - headerWidth) / 2.0), y: 10.0), size: CGSize(width: headerWidth, height: 44.0)))
self.updateTitle(transition: transition)
transition.updateFrame(node: self.optionsButton, frame: CGRect(origin: CGPoint(x: 20.0 + floorToScreenPixels((size.width - headerWidth) / 2.0), y: 18.0), size: CGSize(width: 28.0, height: 28.0)))
transition.updateFrame(node: self.panelButton, frame: CGRect(origin: CGPoint(x: size.width - floorToScreenPixels((size.width - headerWidth) / 2.0) - 20.0 - 28.0 - 38.0 - 24.0, y: 18.0), size: CGSize(width: 38.0, height: 28.0)))
transition.updateFrame(node: self.closeButton, frame: CGRect(origin: CGPoint(x: size.width - floorToScreenPixels((size.width - headerWidth) / 2.0) - 20.0 - 28.0, y: 18.0), size: CGSize(width: 28.0, height: 28.0)))
transition.updateAlpha(node: self.optionsButton, alpha: self.optionsButton.isUserInteractionEnabled ? 1.0 : 0.0)
transition.updateAlpha(node: self.panelButton, alpha: self.panelButton.isUserInteractionEnabled ? 1.0 : 0.0)
transition.updateFrame(node: self.dimNode, frame: CGRect(origin: CGPoint(), size: layout.size))
transition.updateFrame(node: self.contentContainer, frame: CGRect(origin: CGPoint(x: floorToScreenPixels((layout.size.width - size.width) / 2.0), y: 0.0), size: size))
let layoutTopInset: CGFloat = max(layout.statusBarHeight ?? 0.0, layout.safeInsets.top)
let sideInset: CGFloat = 14.0
var listInsets = UIEdgeInsets()
listInsets.left = sideInset + (self.isLandscape ? 0.0 : layout.safeInsets.left)
listInsets.right = sideInset + (self.isLandscape ? 0.0 : layout.safeInsets.right)
let topEdgeOffset: CGFloat
if let statusBarHeight = layout.statusBarHeight {
topEdgeOffset = statusBarHeight
} else {
topEdgeOffset = 44.0
}
if self.isLandscape {
transition.updateFrame(node: self.topPanelEdgeNode, frame: CGRect(x: 0.0, y: -topEdgeOffset, width: size.width, height: topPanelHeight + topEdgeOffset))
} else if let _ = self.panGestureArguments {
} else {
let topEdgeFrame: CGRect
if self.isFullscreen {
topEdgeFrame = CGRect(x: 0.0, y: -topEdgeOffset, width: size.width, height: topPanelHeight + topEdgeOffset)
} else {
topEdgeFrame = CGRect(x: 0.0, y: 0.0, width: size.width, height: topPanelHeight)
}
transition.updateFrame(node: self.topPanelEdgeNode, frame: topEdgeFrame)
}
let bottomPanelHeight = self.effectiveBottomAreaHeight + layout.intrinsicInsets.bottom
var listTopInset = layoutTopInset + topPanelHeight
if self.isLandscape {
listTopInset = topPanelHeight
}
let listSize = CGSize(width: contentWidth, height: layout.size.height - listTopInset - (self.isLandscape ? layout.intrinsicInsets.bottom : bottomPanelHeight) + bottomGradientHeight)
let topInset: CGFloat
if let (panInitialTopInset, panOffset) = self.panGestureArguments {
if self.isExpanded {
topInset = min(self.topInset ?? listSize.height, panInitialTopInset + max(0.0, panOffset))
} else {
topInset = max(0.0, panInitialTopInset + min(0.0, panOffset))
}
} else if case .regular = layout.metrics.widthClass {
topInset = 0.0
} else if let currentTopInset = self.topInset {
topInset = self.isExpanded ? 0.0 : currentTopInset
} else {
topInset = listSize.height - 46.0 - floor(56.0 * 3.5) - bottomGradientHeight
}
transition.updateFrameAsPositionAndBounds(node: self.listContainer, frame: CGRect(origin: CGPoint(), size: size))
transition.updateFrame(node: self.listNode, frame: CGRect(origin: CGPoint(x: contentLeftInset.isZero ? floorToScreenPixels((size.width - contentWidth) / 2.0) : contentLeftInset, y: listTopInset + topInset), size: listSize))
let tileGridSize = CGSize(width: max(0.0, contentLeftInset - sideInset), height: size.height - layout.intrinsicInsets.bottom - listTopInset - topInset)
if contentLeftInset > 0.0 {
self.tileGridNode.isHidden = false
}
if !self.tileGridNode.isHidden {
let _ = self.tileGridNode.update(size: tileGridSize, layoutMode: .grid, items: self.currentTileItems, transition: transition, completion: { [weak self] in
if contentLeftInset.isZero && transition.isAnimated {
self?.tileGridNode.isHidden = true
}
})
}
transition.updateFrame(node: self.tileGridNode, frame: CGRect(origin: CGPoint(x: sideInset, y: listTopInset + topInset), size: tileGridSize))
self.tileGridNode.updateAbsoluteRect(CGRect(origin: CGPoint(), size: tileGridSize), within: tileGridSize)
listInsets.bottom = bottomGradientHeight
let (duration, curve) = listViewAnimationDurationAndCurve(transition: transition)
self.listNode.transaction(deleteIndices: [], insertIndicesAndItems: [], updateIndicesAndItems: [], options: [.Synchronous, .LowLatency], scrollToItem: nil, updateSizeAndInsets: ListViewUpdateSizeAndInsets(size: listSize, insets: listInsets, duration: duration, curve: curve), stationaryItemRange: nil, updateOpaqueState: nil, completion: { _ in })
let fullscreenListWidth: CGFloat
let fullscreenListHeight: CGFloat = 84.0
let fullscreenListTransform: CATransform3D
let fullscreenListInset: CGFloat = 14.0
let fullscreenListUpdateSizeAndInsets: ListViewUpdateSizeAndInsets
let fullscreenListContainerFrame: CGRect
if self.isLandscape {
fullscreenListWidth = layout.size.height
fullscreenListTransform = CATransform3DIdentity
fullscreenListUpdateSizeAndInsets = ListViewUpdateSizeAndInsets(size: CGSize(width: fullscreenListHeight, height: layout.size.height), insets: UIEdgeInsets(top: fullscreenListInset, left: 0.0, bottom: fullscreenListInset, right: 0.0), duration: duration, curve: curve)
fullscreenListContainerFrame = CGRect(x: layout.size.width - min(self.effectiveBottomAreaHeight, fullscreenBottomAreaHeight) - layout.safeInsets.right - fullscreenListHeight - 4.0, y: 0.0, width: fullscreenListHeight, height: layout.size.height)
} else {
fullscreenListWidth = layout.size.width
fullscreenListTransform = CATransform3DMakeRotation(-CGFloat(CGFloat.pi / 2.0), 0.0, 0.0, 1.0)
fullscreenListUpdateSizeAndInsets = ListViewUpdateSizeAndInsets(size: CGSize(width: fullscreenListHeight, height: layout.size.width), insets: UIEdgeInsets(top: fullscreenListInset + layout.safeInsets.left, left: 0.0, bottom: fullscreenListInset + layout.safeInsets.left, right: 0.0), duration: duration, curve: curve)
fullscreenListContainerFrame = CGRect(x: 0.0, y: layout.size.height - min(bottomPanelHeight, fullscreenBottomAreaHeight + layout.intrinsicInsets.bottom) - fullscreenListHeight - 4.0, width: layout.size.width, height: fullscreenListHeight)
}
transition.updateFrame(node: self.fullscreenListContainer, frame: fullscreenListContainerFrame)
self.fullscreenListNode.bounds = CGRect(x: 0.0, y: 0.0, width: fullscreenListHeight, height: fullscreenListWidth)
transition.updatePosition(node: self.fullscreenListNode, position: CGPoint(x: fullscreenListContainerFrame.width / 2.0, y: fullscreenListContainerFrame.height / 2.0))
self.fullscreenListNode.transform = fullscreenListTransform
self.fullscreenListNode.transaction(deleteIndices: [], insertIndicesAndItems: [], updateIndicesAndItems: [], options: [.Synchronous, .LowLatency], scrollToItem: nil, updateSizeAndInsets: fullscreenListUpdateSizeAndInsets, stationaryItemRange: nil, updateOpaqueState: nil, completion: { _ in })
if case .regular = layout.metrics.widthClass {
self.transitionContainerNode.view.mask = nil
} else {
self.transitionContainerNode.view.mask = self.transitionMaskView
}
var childrenLayout = layout
var childrenInsets = childrenLayout.intrinsicInsets
var childrenSafeInsets = childrenLayout.safeInsets
if case .regular = layout.metrics.widthClass {
let childrenLayoutWidth: CGFloat = 375.0
if contentLeftInset.isZero {
childrenSafeInsets.left = floorToScreenPixels((size.width - childrenLayoutWidth) / 2.0)
childrenSafeInsets.right = floorToScreenPixels((size.width - childrenLayoutWidth) / 2.0)
} else {
childrenSafeInsets.left = floorToScreenPixels((contentLeftInset - childrenLayoutWidth) / 2.0)
childrenSafeInsets.right = childrenSafeInsets.left + (size.width - contentLeftInset)
}
} else if !self.isLandscape, case .fullscreen = effectiveDisplayMode {
childrenInsets.bottom += self.effectiveBottomAreaHeight + fullscreenListHeight + 36.0
}
childrenLayout.safeInsets = childrenSafeInsets
childrenLayout.intrinsicInsets = childrenInsets
self.controller?.presentationContext.containerLayoutUpdated(childrenLayout, transition: transition)
var bottomPanelLeftInset = contentLeftInset
var bottomPanelWidth = size.width - contentLeftInset
if case .regular = layout.metrics.widthClass, bottomPanelLeftInset.isZero {
bottomPanelLeftInset = floorToScreenPixels((layout.size.width - contentWidth) / 2.0)
bottomPanelWidth = contentWidth
}
var bottomPanelFrame = CGRect(origin: CGPoint(x: bottomPanelLeftInset, y: layout.size.height - bottomPanelHeight), size: CGSize(width: bottomPanelWidth, height: bottomPanelHeight))
let bottomPanelCoverHeight = bottomAreaHeight + layout.intrinsicInsets.bottom
if self.isLandscape {
bottomPanelFrame = CGRect(origin: CGPoint(x: layout.size.width - fullscreenBottomAreaHeight - layout.safeInsets.right, y: 0.0), size: CGSize(width: fullscreenBottomAreaHeight + layout.safeInsets.right, height: layout.size.height))
}
let bottomGradientFrame = CGRect(origin: CGPoint(x: bottomPanelLeftInset, y: layout.size.height - bottomPanelCoverHeight), size: CGSize(width: bottomPanelWidth, height: bottomGradientHeight))
transition.updateFrame(node: self.bottomGradientNode, frame: bottomGradientFrame)
transition.updateFrame(node: self.bottomPanelNode, frame: bottomPanelFrame)
if let pickerView = self.pickerView {
transition.updateFrame(view: pickerView, frame: CGRect(x: 0.0, y: layout.size.height - bottomPanelHeight - 216.0, width: size.width, height: 216.0))
}
let timerFrame = CGRect(x: 0.0, y: layout.size.height - bottomPanelHeight - 216.0, width: size.width, height: 216.0)
transition.updateFrame(node: self.timerNode, frame: timerFrame)
self.timerNode.update(size: timerFrame.size, scheduleTime: self.callState?.scheduleTimestamp, transition: .immediate)
let scheduleTextSize = self.scheduleTextNode.updateLayout(CGSize(width: size.width - sideInset * 2.0, height: CGFloat.greatestFiniteMagnitude))
self.scheduleTextNode.frame = CGRect(origin: CGPoint(x: floor((size.width - scheduleTextSize.width) / 2.0), y: layout.size.height - layout.intrinsicInsets.bottom - scheduleTextSize.height - 145.0), size: scheduleTextSize)
let centralButtonSide = min(contentWidth, size.height) - 32.0
let centralButtonSize = CGSize(width: centralButtonSide, height: centralButtonSide)
let cameraButtonSize = smallButtonSize
let sideButtonMinimalInset: CGFloat = 16.0
let sideButtonOffset = min(42.0, floor((((contentWidth - 112.0) / 2.0) - sideButtonSize.width) / 2.0))
let sideButtonOrigin = max(sideButtonMinimalInset, floor((contentWidth - 112.0) / 2.0) - sideButtonOffset - sideButtonSize.width)
let smallButtons: Bool
if case .regular = layout.metrics.widthClass {
smallButtons = false
} else {
switch effectiveDisplayMode {
case .modal:
smallButtons = self.isLandscape
case .fullscreen:
smallButtons = true
}
}
let actionButtonState: VoiceChatActionButton.State
let actionButtonTitle: String
let actionButtonSubtitle: String
var actionButtonEnabled = true
if let callState = self.callState, !self.isScheduling {
if callState.scheduleTimestamp != nil {
self.ignoreConnecting = true
if callState.canManageCall {
actionButtonState = .scheduled(state: .start)
actionButtonTitle = self.presentationData.strings.VoiceChat_StartNow
actionButtonSubtitle = ""
} else {
if callState.subscribedToScheduled {
actionButtonState = .scheduled(state: .unsubscribe)
actionButtonTitle = self.presentationData.strings.VoiceChat_CancelReminder
} else {
actionButtonState = .scheduled(state: .subscribe)
actionButtonTitle = self.presentationData.strings.VoiceChat_SetReminder
}
actionButtonSubtitle = ""
}
} else {
let connected = self.ignoreConnecting || callState.networkState == .connected
if case .connected = callState.networkState {
self.ignoreConnecting = false
self.ignoreConnectingTimer?.invalidate()
self.ignoreConnectingTimer = nil
} else if self.ignoreConnecting {
if self.ignoreConnectingTimer == nil {
let timer = SwiftSignalKit.Timer(timeout: 3.0, repeat: false, completion: { [weak self] in
if let strongSelf = self {
strongSelf.ignoreConnecting = false
strongSelf.ignoreConnectingTimer?.invalidate()
strongSelf.ignoreConnectingTimer = nil
if let (layout, navigationHeight) = strongSelf.validLayout {
strongSelf.containerLayoutUpdated(layout, navigationHeight: navigationHeight, transition: .immediate)
}
}
}, queue: Queue.mainQueue())
self.ignoreConnectingTimer = timer
timer.start()
}
}
if connected {
if let muteState = callState.muteState, !self.pushingToTalk && !self.temporaryPushingToTalk {
if muteState.canUnmute {
actionButtonState = .active(state: .muted)
actionButtonTitle = self.presentationData.strings.VoiceChat_Unmute
actionButtonSubtitle = ""
} else {
actionButtonState = .active(state: .cantSpeak)
if callState.raisedHand {
actionButtonTitle = self.presentationData.strings.VoiceChat_AskedToSpeak
actionButtonSubtitle = self.presentationData.strings.VoiceChat_AskedToSpeakHelp
} else {
actionButtonTitle = self.presentationData.strings.VoiceChat_MutedByAdmin
actionButtonSubtitle = self.presentationData.strings.VoiceChat_MutedByAdminHelp
}
}
} else {
actionButtonState = .active(state: .on)
actionButtonTitle = self.pushingToTalk ? self.presentationData.strings.VoiceChat_Live : self.presentationData.strings.VoiceChat_Mute
actionButtonSubtitle = ""
}
} else {
actionButtonState = .connecting
actionButtonTitle = self.presentationData.strings.VoiceChat_Connecting
actionButtonSubtitle = ""
actionButtonEnabled = false
}
}
} else {
if self.isScheduling {
actionButtonState = .button(text: self.scheduleButtonTitle)
actionButtonTitle = ""
actionButtonSubtitle = ""
actionButtonEnabled = true
} else {
actionButtonState = .connecting
actionButtonTitle = self.presentationData.strings.VoiceChat_Connecting
actionButtonSubtitle = ""
actionButtonEnabled = false
}
}
self.actionButton.isDisabled = !actionButtonEnabled
self.actionButton.update(size: centralButtonSize, buttonSize: CGSize(width: 112.0, height: 112.0), state: actionButtonState, title: actionButtonTitle, subtitle: actionButtonSubtitle, dark: self.isFullscreen, small: smallButtons, animated: true)
let isVideoEnabled = self.callState?.isVideoEnabled ?? false
var hasCameraButton = isVideoEnabled
if let joinedVideo = self.joinedVideo {
hasCameraButton = joinedVideo
}
if !isVideoEnabled {
hasCameraButton = false
}
switch actionButtonState {
case let .active(state):
switch state {
case .cantSpeak:
hasCameraButton = false
case .on, .muted:
break
}
case .connecting:
if !self.connectedOnce {
hasCameraButton = false
}
case .scheduled, .button:
hasCameraButton = false
}
let hasVideo = hasCameraButton && self.call.hasVideo
let upperButtonDistance: CGFloat = 12.0
let firstButtonFrame: CGRect
let secondButtonFrame: CGRect
let thirdButtonFrame: CGRect
let forthButtonFrame: CGRect
let leftButtonFrame: CGRect
if self.isScheduled || !hasVideo {
leftButtonFrame = CGRect(origin: CGPoint(x: sideButtonOrigin, y: floor((self.effectiveBottomAreaHeight - sideButtonSize.height) / 2.0)), size: sideButtonSize)
} else {
leftButtonFrame = CGRect(origin: CGPoint(x: sideButtonOrigin, y: floor((self.effectiveBottomAreaHeight - sideButtonSize.height - upperButtonDistance - cameraButtonSize.height) / 2.0) + upperButtonDistance + cameraButtonSize.height), size: sideButtonSize)
}
let rightButtonFrame = CGRect(origin: CGPoint(x: contentWidth - sideButtonOrigin - sideButtonSize.width, y: floor((self.effectiveBottomAreaHeight - sideButtonSize.height) / 2.0)), size: sideButtonSize)
var centerButtonFrame = CGRect(origin: CGPoint(x: floorToScreenPixels((size.width - centralButtonSize.width) / 2.0), y: floor((self.effectiveBottomAreaHeight - centralButtonSize.height) / 2.0) - 3.0), size: centralButtonSize)
if case .regular = layout.metrics.widthClass {
centerButtonFrame = CGRect(origin: CGPoint(x: floorToScreenPixels((contentWidth - centralButtonSize.width) / 2.0), y: floor((self.effectiveBottomAreaHeight - centralButtonSize.height) / 2.0) - 3.0), size: centralButtonSize)
if hasCameraButton {
firstButtonFrame = CGRect(origin: CGPoint(x: floor(leftButtonFrame.midX - cameraButtonSize.width / 2.0), y: leftButtonFrame.minY - upperButtonDistance - cameraButtonSize.height), size: cameraButtonSize)
} else {
firstButtonFrame = CGRect(origin: CGPoint(x: leftButtonFrame.center.x - cameraButtonSize.width / 2.0, y: leftButtonFrame.center.y - cameraButtonSize.height / 2.0), size: cameraButtonSize)
}
secondButtonFrame = leftButtonFrame
thirdButtonFrame = centerButtonFrame
forthButtonFrame = rightButtonFrame
} else {
switch effectiveDisplayMode {
case .modal:
if self.isLandscape {
let sideInset: CGFloat
let buttonsCount: Int
if hasVideo {
sideInset = 26.0
buttonsCount = 4
} else {
sideInset = 42.0
buttonsCount = 3
}
let spacing = floor((layout.size.height - sideInset * 2.0 - sideButtonSize.height * CGFloat(buttonsCount)) / (CGFloat(buttonsCount - 1)))
let x = floor((fullscreenBottomAreaHeight - sideButtonSize.width) / 2.0)
forthButtonFrame = CGRect(origin: CGPoint(x: x, y: sideInset), size: sideButtonSize)
let thirdButtonPreFrame = CGRect(origin: CGPoint(x: x, y: sideInset + sideButtonSize.height + spacing), size: sideButtonSize)
thirdButtonFrame = CGRect(origin: CGPoint(x: floor(thirdButtonPreFrame.midX - centralButtonSize.width / 2.0), y: floor(thirdButtonPreFrame.midY - centralButtonSize.height / 2.0)), size: centralButtonSize)
secondButtonFrame = CGRect(origin: CGPoint(x: x, y: thirdButtonPreFrame.maxY + spacing), size: sideButtonSize)
if hasCameraButton {
firstButtonFrame = CGRect(origin: CGPoint(x: x, y: layout.size.height - sideInset - sideButtonSize.height), size: sideButtonSize)
} else {
firstButtonFrame = secondButtonFrame
}
} else {
if hasCameraButton {
firstButtonFrame = CGRect(origin: CGPoint(x: floor(leftButtonFrame.midX - cameraButtonSize.width / 2.0), y: leftButtonFrame.minY - upperButtonDistance - cameraButtonSize.height), size: cameraButtonSize)
} else {
firstButtonFrame = CGRect(origin: CGPoint(x: leftButtonFrame.center.x - cameraButtonSize.width / 2.0, y: leftButtonFrame.center.y - cameraButtonSize.height / 2.0), size: cameraButtonSize)
}
secondButtonFrame = leftButtonFrame
thirdButtonFrame = centerButtonFrame
forthButtonFrame = rightButtonFrame
}
case let .fullscreen(controlsHidden):
if self.isLandscape {
let sideInset: CGFloat
let buttonsCount: Int
if hasVideo {
sideInset = 26.0
buttonsCount = 4
} else {
sideInset = 42.0
buttonsCount = 3
}
let spacing = floor((layout.size.height - sideInset * 2.0 - sideButtonSize.height * CGFloat(buttonsCount)) / (CGFloat(buttonsCount - 1)))
let x = controlsHidden ? fullscreenBottomAreaHeight + layout.safeInsets.right + 30.0 : floor((fullscreenBottomAreaHeight - sideButtonSize.width) / 2.0)
forthButtonFrame = CGRect(origin: CGPoint(x: x, y: sideInset), size: sideButtonSize)
let thirdButtonPreFrame = CGRect(origin: CGPoint(x: x, y: sideInset + sideButtonSize.height + spacing), size: sideButtonSize)
thirdButtonFrame = CGRect(origin: CGPoint(x: floor(thirdButtonPreFrame.midX - centralButtonSize.width / 2.0), y: floor(thirdButtonPreFrame.midY - centralButtonSize.height / 2.0)), size: centralButtonSize)
secondButtonFrame = CGRect(origin: CGPoint(x: x, y: thirdButtonPreFrame.maxY + spacing), size: sideButtonSize)
if hasVideo {
firstButtonFrame = CGRect(origin: CGPoint(x: x, y: layout.size.height - sideInset - sideButtonSize.height), size: sideButtonSize)
} else {
firstButtonFrame = secondButtonFrame
}
} else {
let sideInset: CGFloat
let buttonsCount: Int
if hasVideo {
sideInset = 26.0
buttonsCount = 4
} else {
sideInset = 42.0
buttonsCount = 3
}
let spacing = floor((layout.size.width - sideInset * 2.0 - sideButtonSize.width * CGFloat(buttonsCount)) / (CGFloat(buttonsCount - 1)))
let y = controlsHidden ? self.effectiveBottomAreaHeight + layout.intrinsicInsets.bottom + 30.0: floor((self.effectiveBottomAreaHeight - sideButtonSize.height) / 2.0)
if hasVideo {
firstButtonFrame = CGRect(origin: CGPoint(x: sideInset, y: y), size: sideButtonSize)
secondButtonFrame = CGRect(origin: CGPoint(x: firstButtonFrame.maxX + spacing, y: y), size: sideButtonSize)
} else {
firstButtonFrame = CGRect(origin: CGPoint(x: sideInset, y: y), size: sideButtonSize)
secondButtonFrame = firstButtonFrame
}
let thirdButtonPreFrame = CGRect(origin: CGPoint(x: secondButtonFrame.maxX + spacing, y: y), size: sideButtonSize)
thirdButtonFrame = CGRect(origin: CGPoint(x: floor(thirdButtonPreFrame.midX - centralButtonSize.width / 2.0), y: floor(thirdButtonPreFrame.midY - centralButtonSize.height / 2.0)), size: centralButtonSize)
forthButtonFrame = CGRect(origin: CGPoint(x: thirdButtonPreFrame.maxX + spacing, y: y), size: sideButtonSize)
}
}
}
let buttonWidth = min(size.width - 32.0, centralButtonSize.width)
let buttonHeight = self.scheduleCancelButton.updateLayout(width: buttonWidth, transition: .immediate)
self.scheduleCancelButton.frame = CGRect(x: floorToScreenPixels(centerButtonFrame.midX - buttonWidth / 2.0), y: 137.0, width: buttonWidth, height: buttonHeight)
if self.actionButton.supernode === self.bottomPanelNode {
transition.updateFrame(node: self.actionButton, frame: thirdButtonFrame, completion: transition.isAnimated ? { [weak self] _ in
self?.animatingExpansion = false
} : nil)
}
self.cameraButton.isUserInteractionEnabled = hasCameraButton
var buttonsTransition: ContainedViewLayoutTransition = .immediate
if !isFirstTime {
if case .animated(_, .spring) = transition {
buttonsTransition = transition
} else {
buttonsTransition = .animated(duration: 0.3, curve: .linear)
}
}
self.updateButtons(transition: buttonsTransition)
if self.audioButton.supernode === self.bottomPanelNode {
transition.updateAlpha(node: self.cameraButton, alpha: hasCameraButton ? 1.0 : 0.0)
transition.updateFrameAsPositionAndBounds(node: self.switchCameraButton, frame: firstButtonFrame)
if !self.animatingButtonsSwap || transition.isAnimated {
transition.updateFrameAsPositionAndBounds(node: self.audioButton, frame: secondButtonFrame, completion: { [weak self] _ in
self?.animatingButtonsSwap = false
})
transition.updateFrameAsPositionAndBounds(node: self.cameraButton, frame: secondButtonFrame)
}
transition.updateFrameAsPositionAndBounds(node: self.leaveButton, frame: forthButtonFrame)
}
if isFirstTime {
while !self.enqueuedTransitions.isEmpty {
self.dequeueTransition()
}
while !self.enqueuedFullscreenTransitions.isEmpty {
self.dequeueFullscreenTransition()
}
}
}
private var appIsActive = true {
didSet {
if self.appIsActive != oldValue {
self.updateVisibility()
self.updateRequestedVideoChannels()
}
}
}
private var visibility = false {
didSet {
if self.visibility != oldValue {
self.updateVisibility()
self.updateRequestedVideoChannels()
}
}
}
private func updateVisibility() {
let visible = self.appIsActive && self.visibility
if self.tileGridNode.isHidden {
self.tileGridNode.visibility = false
} else {
self.tileGridNode.visibility = visible
}
self.mainStageNode.visibility = visible
self.listNode.forEachItemNode { itemNode in
if let itemNode = itemNode as? VoiceChatTilesGridItemNode {
itemNode.gridVisibility = visible
}
}
self.fullscreenListNode.forEachItemNode { itemNode in
if let itemNode = itemNode as? VoiceChatFullscreenParticipantItemNode {
itemNode.gridVisibility = visible
}
}
self.videoRenderingContext.updateVisibility(isVisible: visible)
}
func animateIn() {
guard let (layout, navigationHeight) = self.validLayout else {
return
}
self.visibility = true
self.updateDecorationsLayout(transition: .immediate)
self.animatingAppearance = true
let initialBounds = self.contentContainer.bounds
let topPanelFrame = self.topPanelNode.view.convert(self.topPanelNode.bounds, to: self.view)
self.contentContainer.bounds = initialBounds.offsetBy(dx: 0.0, dy: -(layout.size.height - topPanelFrame.minY))
self.contentContainer.isHidden = false
let transition = ContainedViewLayoutTransition.animated(duration: 0.4, curve: .spring)
transition.animateView({
self.contentContainer.view.bounds = initialBounds
}, completion: { _ in
self.animatingAppearance = false
if self.actionButton.supernode !== self.bottomPanelNode {
self.actionButton.ignoreHierarchyChanges = true
self.audioButton.isHidden = false
self.cameraButton.isHidden = false
self.leaveButton.isHidden = false
self.audioButton.layer.removeAllAnimations()
self.cameraButton.layer.removeAllAnimations()
self.leaveButton.layer.removeAllAnimations()
self.bottomPanelNode.addSubnode(self.cameraButton)
self.bottomPanelNode.addSubnode(self.audioButton)
self.bottomPanelNode.addSubnode(self.leaveButton)
self.bottomPanelNode.addSubnode(self.actionButton)
self.containerLayoutUpdated(layout, navigationHeight: navigationHeight, transition: .immediate)
self.actionButton.ignoreHierarchyChanges = false
}
self.controller?.currentOverlayController?.dismiss()
self.controller?.currentOverlayController = nil
})
self.dimNode.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.3)
}
func animateOut(completion: (() -> Void)?) {
guard let (layout, _) = self.validLayout else {
return
}
var offsetCompleted = false
let internalCompletion: () -> Void = { [weak self] in
if offsetCompleted {
if let strongSelf = self {
strongSelf.contentContainer.layer.removeAllAnimations()
strongSelf.dimNode.layer.removeAllAnimations()
var bounds = strongSelf.contentContainer.bounds
bounds.origin.y = 0.0
strongSelf.contentContainer.bounds = bounds
strongSelf.visibility = false
}
completion?()
}
}
let topPanelFrame = self.topPanelNode.view.convert(self.topPanelNode.bounds, to: self.view)
self.contentContainer.layer.animateBoundsOriginYAdditive(from: self.contentContainer.bounds.origin.y, to: -(layout.size.height - topPanelFrame.minY) - 44.0, duration: 0.3, timingFunction: kCAMediaTimingFunctionSpring, removeOnCompletion: false, completion: { _ in
offsetCompleted = true
internalCompletion()
})
self.dimNode.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.2, removeOnCompletion: false)
}
private func enqueueTransition(_ transition: ListTransition) {
self.enqueuedTransitions.append(transition)
if let _ = self.validLayout {
while !self.enqueuedTransitions.isEmpty {
self.dequeueTransition()
}
}
}
private func enqueueFullscreenTransition(_ transition: ListTransition) {
self.enqueuedFullscreenTransitions.append(transition)
if let _ = self.validLayout {
while !self.enqueuedFullscreenTransitions.isEmpty {
self.dequeueFullscreenTransition()
}
}
}
private func dequeueTransition() {
guard let (layout, _) = self.validLayout, let transition = self.enqueuedTransitions.first else {
return
}
self.enqueuedTransitions.remove(at: 0)
if let callState = self.callState {
if callState.scheduleTimestamp != nil && self.listNode.alpha > 0.0 {
self.timerNode.isHidden = false
self.cameraButton.alpha = 0.0
self.cameraButton.isUserInteractionEnabled = false
self.listNode.alpha = 0.0
self.listNode.isUserInteractionEnabled = false
self.backgroundNode.backgroundColor = panelBackgroundColor
self.updateDecorationsColors()
} else if callState.scheduleTimestamp == nil && !self.isScheduling && self.listNode.alpha == 0.0 {
self.transitionToCall()
}
}
var options = ListViewDeleteAndInsertOptions()
let isFirstTime = self.isFirstTime
if isFirstTime {
self.isFirstTime = false
} else {
if transition.crossFade {
options.insert(.AnimateCrossfade)
}
if transition.animated {
options.insert(.AnimateInsertion)
}
}
options.insert(.LowLatency)
options.insert(.PreferSynchronousResourceLoading)
var size = layout.size
if case .regular = layout.metrics.widthClass {
size.width = floor(min(size.width, size.height) * 0.5)
}
let bottomPanelHeight = self.isLandscape ? layout.intrinsicInsets.bottom : bottomAreaHeight + layout.intrinsicInsets.bottom
let layoutTopInset: CGFloat = max(layout.statusBarHeight ?? 0.0, layout.safeInsets.top)
let listTopInset = layoutTopInset + topPanelHeight
let listSize = CGSize(width: size.width, height: layout.size.height - listTopInset - bottomPanelHeight + bottomGradientHeight)
self.topInset = listSize.height - 46.0 - floor(56.0 * 3.5) - bottomGradientHeight
if transition.animated {
self.animatingInsertion = true
}
self.listNode.transaction(deleteIndices: transition.deletions, insertIndicesAndItems: transition.insertions, updateIndicesAndItems: transition.updates, options: options, scrollToItem: nil, updateSizeAndInsets: nil, updateOpaqueState: nil, completion: { [weak self] _ in
guard let strongSelf = self else {
return
}
if isFirstTime {
strongSelf.updateDecorationsLayout(transition: .immediate)
} else if strongSelf.animatingInsertion {
strongSelf.updateDecorationsLayout(transition: .animated(duration: 0.2, curve: .easeInOut))
}
strongSelf.animatingInsertion = false
if !strongSelf.didSetContentsReady {
strongSelf.didSetContentsReady = true
strongSelf.controller?.contentsReady.set(true)
}
strongSelf.updateVisibility()
})
}
private func dequeueFullscreenTransition() {
guard let _ = self.validLayout, let transition = self.enqueuedFullscreenTransitions.first else {
return
}
self.enqueuedFullscreenTransitions.remove(at: 0)
var options = ListViewDeleteAndInsertOptions()
let isFirstTime = self.isFirstTime
if !isFirstTime {
if transition.animated {
options.insert(.AnimateInsertion)
}
}
self.fullscreenListNode.transaction(deleteIndices: transition.deletions, insertIndicesAndItems: transition.insertions, updateIndicesAndItems: transition.updates, options: options, scrollToItem: nil, updateSizeAndInsets: nil, updateOpaqueState: nil, completion: { _ in
})
}
private func updateMembers(maybeUpdateVideo: Bool = true, force: Bool = false) {
self.updateMembers(muteState: self.effectiveMuteState, callMembers: self.currentCallMembers ?? ([], nil), invitedPeers: self.currentInvitedPeers ?? [], speakingPeers: self.currentSpeakingPeers ?? Set(), maybeUpdateVideo: maybeUpdateVideo, force: force)
}
private func updateMembers(muteState: GroupCallParticipantsContext.Participant.MuteState?, callMembers: ([GroupCallParticipantsContext.Participant], String?), invitedPeers: [EnginePeer], speakingPeers: Set<EnginePeer.Id>, maybeUpdateVideo: Bool = true, force: Bool = false) {
var disableAnimation = false
if self.currentCallMembers?.1 != callMembers.1 {
disableAnimation = true
}
let speakingPeersUpdated = self.currentSpeakingPeers != speakingPeers
self.currentCallMembers = callMembers
self.currentInvitedPeers = invitedPeers
var entries: [ListEntry] = []
var fullscreenEntries: [ListEntry] = []
var index: Int32 = 0
var fullscreenIndex: Int32 = 0
var processedPeerIds = Set<PeerId>()
var processedFullscreenPeerIds = Set<PeerId>()
var peerIdToCameraEndpointId: [PeerId: String] = [:]
var peerIdToEndpointId: [PeerId: String] = [:]
var requestedVideoChannels: [PresentationGroupCallRequestedVideo] = []
var gridTileItems: [VoiceChatTileItem] = []
var tileItems: [VoiceChatTileItem] = []
var gridTileByVideoEndpoint: [String: VoiceChatTileItem] = [:]
var tileByVideoEndpoint: [String: VoiceChatTileItem] = [:]
var entryByPeerId: [PeerId: VoiceChatPeerEntry] = [:]
var latestWideVideo: String? = nil
var isTablet = false
var displayPanelVideos = false
if let (layout, _) = self.validLayout, case .regular = layout.metrics.widthClass {
isTablet = true
displayPanelVideos = self.displayPanelVideos
}
// let isLivestream: Bool
// if let channel = self.peer as? TelegramChannel, case .broadcast = channel.info {
// isLivestream = true
// } else {
// isLivestream = false
// }
let canManageCall = self.callState?.canManageCall ?? false
var joinedVideo = self.joinedVideo ?? true
var myEntry: VoiceChatPeerEntry?
var mainEntry: VoiceChatPeerEntry?
for member in callMembers.0 {
if processedPeerIds.contains(member.peer.id) {
continue
}
processedPeerIds.insert(member.peer.id)
let memberState: VoiceChatPeerEntry.State
var memberMuteState: GroupCallParticipantsContext.Participant.MuteState?
if member.hasRaiseHand && !(member.muteState?.canUnmute ?? true) {
// if isLivestream && !canManageCall {
// continue
// }
memberState = .raisedHand
memberMuteState = member.muteState
if self.raisedHandDisplayDisposables[member.peer.id] == nil {
var displayedRaisedHands = self.displayedRaisedHands
displayedRaisedHands.insert(member.peer.id)
self.displayedRaisedHands = displayedRaisedHands
let signal: Signal<Never, NoError> = Signal.complete() |> delay(3.0, queue: Queue.mainQueue())
self.raisedHandDisplayDisposables[member.peer.id] = signal.start(completed: { [weak self] in
if let strongSelf = self {
var displayedRaisedHands = strongSelf.displayedRaisedHands
displayedRaisedHands.remove(member.peer.id)
strongSelf.displayedRaisedHands = displayedRaisedHands
strongSelf.updateMembers()
}
})
}
} else {
if member.peer.id == self.callState?.myPeerId {
if muteState == nil {
memberState = speakingPeers.contains(member.peer.id) ? .speaking : .listening
} else {
memberState = .listening
memberMuteState = member.muteState
}
} else {
memberState = speakingPeers.contains(member.peer.id) ? .speaking : .listening
memberMuteState = member.muteState
}
if let disposable = self.raisedHandDisplayDisposables[member.peer.id] {
disposable.dispose()
self.raisedHandDisplayDisposables[member.peer.id] = nil
}
// if isLivestream && !(memberMuteState?.canUnmute ?? true) {
// continue
// }
}
var memberPeer = member.peer
if member.peer.id == self.callState?.myPeerId {
joinedVideo = member.joinedVideo
if let user = memberPeer as? TelegramUser, let photo = self.currentUpdatingAvatar {
memberPeer = user.withUpdatedPhoto([photo])
}
}
joinedVideo = true
if let videoEndpointId = member.videoEndpointId {
peerIdToCameraEndpointId[member.peer.id] = videoEndpointId
}
if let anyEndpointId = member.presentationEndpointId ?? member.videoEndpointId {
peerIdToEndpointId[member.peer.id] = anyEndpointId
}
let peerEntry = VoiceChatPeerEntry(
peer: memberPeer,
about: member.about,
isMyPeer: self.callState?.myPeerId == member.peer.id,
videoEndpointId: member.videoEndpointId,
videoPaused: member.videoDescription?.isPaused ?? false,
presentationEndpointId: member.presentationEndpointId,
presentationPaused: member.presentationDescription?.isPaused ?? false,
effectiveSpeakerVideoEndpointId: self.effectiveSpeaker?.1,
state: memberState,
muteState: memberMuteState,
canManageCall: canManageCall,
volume: member.volume,
raisedHand: member.hasRaiseHand,
displayRaisedHandStatus: self.displayedRaisedHands.contains(member.peer.id),
active: memberPeer.id == self.effectiveSpeaker?.0,
isLandscape: self.isLandscape
)
if peerEntry.isMyPeer {
myEntry = peerEntry
}
if peerEntry.active {
mainEntry = peerEntry
}
entryByPeerId[peerEntry.peer.id] = peerEntry
var isTile = false
if let interaction = self.itemInteraction {
if let videoEndpointId = member.presentationEndpointId {
if !self.videoOrder.contains(videoEndpointId) {
if peerEntry.isMyPeer {
self.videoOrder.insert(videoEndpointId, at: 0)
} else {
self.videoOrder.append(videoEndpointId)
}
}
if isTablet {
if let tileItem = ListEntry.peer(peerEntry, 0).tileItem(context: self.context, presentationData: self.presentationData, interaction: interaction, isTablet: isTablet, videoEndpointId: videoEndpointId, videoReady: self.readyVideoEndpointIds.contains(videoEndpointId), videoTimeouted: self.timeoutedEndpointIds.contains(videoEndpointId), videoIsPaused: member.presentationDescription?.isPaused ?? false, showAsPresentation: peerIdToCameraEndpointId[peerEntry.peer.id] != nil, secondary: false) {
isTile = true
gridTileByVideoEndpoint[videoEndpointId] = tileItem
}
}
if let tileItem = ListEntry.peer(peerEntry, 0).tileItem(context: self.context, presentationData: self.presentationData, interaction: interaction, isTablet: isTablet, videoEndpointId: videoEndpointId, videoReady: self.readyVideoEndpointIds.contains(videoEndpointId), videoTimeouted: self.timeoutedEndpointIds.contains(videoEndpointId), videoIsPaused: member.presentationDescription?.isPaused ?? false, showAsPresentation: peerIdToCameraEndpointId[peerEntry.peer.id] != nil, secondary: displayPanelVideos) {
isTile = true
tileByVideoEndpoint[videoEndpointId] = tileItem
}
if self.wideVideoNodes.contains(videoEndpointId) {
latestWideVideo = videoEndpointId
}
}
if let videoEndpointId = member.videoEndpointId {
if !self.videoOrder.contains(videoEndpointId) {
if peerEntry.isMyPeer {
self.videoOrder.insert(videoEndpointId, at: 0)
} else {
self.videoOrder.append(videoEndpointId)
}
}
if isTablet {
if let tileItem = ListEntry.peer(peerEntry, 0).tileItem(context: self.context, presentationData: self.presentationData, interaction: interaction, isTablet: isTablet, videoEndpointId: videoEndpointId, videoReady: self.readyVideoEndpointIds.contains(videoEndpointId), videoTimeouted: self.timeoutedEndpointIds.contains(videoEndpointId), videoIsPaused: member.videoDescription?.isPaused ?? false, showAsPresentation: false, secondary: false) {
isTile = true
gridTileByVideoEndpoint[videoEndpointId] = tileItem
}
}
if let tileItem = ListEntry.peer(peerEntry, 0).tileItem(context: self.context, presentationData: self.presentationData, interaction: interaction, isTablet: isTablet, videoEndpointId: videoEndpointId, videoReady: self.readyVideoEndpointIds.contains(videoEndpointId), videoTimeouted: self.timeoutedEndpointIds.contains(videoEndpointId), videoIsPaused: member.videoDescription?.isPaused ?? false, showAsPresentation: false, secondary: displayPanelVideos) {
isTile = true
tileByVideoEndpoint[videoEndpointId] = tileItem
}
if self.wideVideoNodes.contains(videoEndpointId) {
latestWideVideo = videoEndpointId
}
}
}
if !isTile || isTablet || !joinedVideo {
entries.append(.peer(peerEntry, index))
}
index += 1
if self.callState?.networkState == .connecting {
} else {
if var videoChannel = member.requestedVideoChannel(minQuality: .thumbnail, maxQuality: .medium) {
if self.effectiveSpeaker?.1 == videoChannel.endpointId {
videoChannel.maxQuality = .full
}
requestedVideoChannels.append(videoChannel)
}
if member.peer.id != self.callState?.myPeerId {
if var presentationChannel = member.requestedPresentationVideoChannel(minQuality: .thumbnail, maxQuality: .thumbnail) {
if self.effectiveSpeaker?.1 == presentationChannel.endpointId {
presentationChannel.minQuality = .full
presentationChannel.maxQuality = .full
}
requestedVideoChannels.append(presentationChannel)
}
}
}
}
var temporaryList: [String] = []
for tileVideoEndpoint in self.videoOrder {
if let _ = tileByVideoEndpoint[tileVideoEndpoint] {
temporaryList.append(tileVideoEndpoint)
}
}
if (tileByVideoEndpoint.count % 2) != 0, let last = temporaryList.last, !self.wideVideoNodes.contains(last), let latestWide = latestWideVideo {
self.videoOrder.removeAll(where: { $0 == latestWide })
self.videoOrder.append(latestWide)
}
for tileVideoEndpoint in self.videoOrder {
if let tileItem = gridTileByVideoEndpoint[tileVideoEndpoint] {
gridTileItems.append(tileItem)
}
if let tileItem = tileByVideoEndpoint[tileVideoEndpoint] {
if displayPanelVideos && tileItem.peer.id == self.effectiveSpeaker?.0 {
} else {
tileItems.append(tileItem)
}
if let fullscreenEntry = entryByPeerId[tileItem.peer.id] {
if processedFullscreenPeerIds.contains(tileItem.peer.id) {
continue
}
fullscreenEntries.append(.peer(fullscreenEntry, fullscreenIndex))
processedFullscreenPeerIds.insert(fullscreenEntry.peer.id)
fullscreenIndex += 1
}
}
}
self.joinedVideo = joinedVideo
let configuration = self.configuration ?? VoiceChatConfiguration.defaultValue
var reachedLimit = false
if !joinedVideo && (!tileItems.isEmpty || !gridTileItems.isEmpty), let peer = self.peer {
tileItems.removeAll()
gridTileItems.removeAll()
tileItems.append(VoiceChatTileItem(account: self.context.account, peer: EnginePeer(peer), videoEndpointId: "", videoReady: false, videoTimeouted: true, isVideoLimit: true, videoLimit: configuration.videoParticipantsMaxCount, isPaused: false, isOwnScreencast: false, strings: self.presentationData.strings, nameDisplayOrder: self.presentationData.nameDisplayOrder, speaking: false, secondary: false, isTablet: false, icon: .none, text: .none, additionalText: nil, action: {}, contextAction: nil, getVideo: { _ in return nil }, getAudioLevel: nil))
} else if let callState = self.callState, !tileItems.isEmpty && callState.isVideoWatchersLimitReached && self.connectedOnce && (callState.canManageCall || callState.adminIds.contains(self.context.account.peerId)) {
reachedLimit = true
}
for member in callMembers.0 {
if processedFullscreenPeerIds.contains(member.peer.id) {
continue
}
processedFullscreenPeerIds.insert(member.peer.id)
if let peerEntry = entryByPeerId[member.peer.id] {
fullscreenEntries.append(.peer(peerEntry, fullscreenIndex))
fullscreenIndex += 1
}
}
for peer in invitedPeers {
if processedPeerIds.contains(peer.id) {
continue
}
processedPeerIds.insert(peer.id)
entries.append(.peer(VoiceChatPeerEntry(
peer: peer._asPeer(),
about: nil,
isMyPeer: false,
videoEndpointId: nil,
videoPaused: false,
presentationEndpointId: nil,
presentationPaused: false,
effectiveSpeakerVideoEndpointId: nil,
state: .invited,
muteState: nil,
canManageCall: false,
volume: nil,
raisedHand: false,
displayRaisedHandStatus: false,
active: false,
isLandscape: false
), index))
index += 1
}
self.requestedVideoChannels = requestedVideoChannels
var myVideoUpdated = false
if let previousMyEntry = self.myEntry, let myEntry = myEntry, previousMyEntry.effectiveVideoEndpointId == nil && myEntry.effectiveVideoEndpointId != nil && self.currentForcedSpeaker == nil {
self.currentDominantSpeaker = (myEntry.peer.id, myEntry.effectiveVideoEndpointId, CACurrentMediaTime())
myVideoUpdated = true
}
self.myEntry = myEntry
guard self.didSetDataReady && (force || (!self.isPanning && !self.animatingExpansion && !self.animatingMainStage)) else {
return
}
let previousMainEntry = self.mainEntry
self.mainEntry = mainEntry
if let mainEntry = mainEntry {
self.mainStageNode.update(peerEntry: mainEntry, pinned: self.currentForcedSpeaker != nil)
if let previousMainEntry = previousMainEntry, maybeUpdateVideo {
if previousMainEntry.effectiveVideoEndpointId != mainEntry.effectiveVideoEndpointId || previousMainEntry.videoPaused != mainEntry.videoPaused || myVideoUpdated {
self.updateMainVideo(waitForFullSize: true, entries: fullscreenEntries, force: true)
return
}
}
} else if self.effectiveSpeaker != nil, !fullscreenEntries.isEmpty {
self.updateMainVideo(waitForFullSize: true, entries: fullscreenEntries, force: true)
return
}
self.updateRequestedVideoChannels()
self.currentSpeakingPeers = speakingPeers
self.peerIdToEndpointId = peerIdToEndpointId
var updateLayout = false
var animatingLayout = false
if self.currentTileItems.isEmpty != gridTileItems.isEmpty {
animatingLayout = true
updateLayout = true
}
if isTablet {
updateLayout = true
self.currentTileItems = gridTileItems
if displayPanelVideos && !tileItems.isEmpty {
entries.insert(.tiles(tileItems, .pairs, configuration.videoParticipantsMaxCount, reachedLimit), at: 0)
}
} else {
if !tileItems.isEmpty {
entries.insert(.tiles(tileItems, .pairs, configuration.videoParticipantsMaxCount, reachedLimit), at: 0)
}
}
var canInvite = true
var inviteIsLink = false
if let peer = self.peer as? TelegramChannel {
if peer.flags.contains(.isGigagroup) {
if peer.flags.contains(.isCreator) || peer.adminRights != nil {
} else {
canInvite = false
}
}
if case .broadcast = peer.info, !(peer.addressName?.isEmpty ?? true) {
inviteIsLink = true
}
}
if canInvite {
entries.append(.invite(self.presentationData.theme, self.presentationData.strings, inviteIsLink ? self.presentationData.strings.VoiceChat_Share : self.presentationData.strings.VoiceChat_InviteMember, inviteIsLink))
}
let previousEntries = self.currentEntries
let previousFullscreenEntries = self.currentFullscreenEntries
self.currentEntries = entries
self.currentFullscreenEntries = fullscreenEntries
if previousEntries.count == entries.count {
var allEqual = true
for i in 0 ..< previousEntries.count {
if previousEntries[i].stableId != entries[i].stableId {
if case let .peer(lhsPeer, _) = previousEntries[i], case let .peer(rhsPeer, _) = entries[i] {
if lhsPeer.isMyPeer != rhsPeer.isMyPeer {
allEqual = false
break
}
} else {
allEqual = false
break
}
}
}
if allEqual {
disableAnimation = true
}
} else if abs(previousEntries.count - entries.count) > 10 {
disableAnimation = true
}
let presentationData = self.presentationData.withUpdated(theme: self.darkTheme)
let transition = self.preparedTransition(from: previousEntries, to: entries, isLoading: false, isEmpty: false, canInvite: canInvite, crossFade: false, animated: !disableAnimation, context: self.context, presentationData: presentationData, interaction: self.itemInteraction!)
self.enqueueTransition(transition)
let fullscreenTransition = self.preparedFullscreenTransition(from: previousFullscreenEntries, to: fullscreenEntries, isLoading: false, isEmpty: false, canInvite: canInvite, crossFade: false, animated: true, context: self.context, presentationData: presentationData, interaction: self.itemInteraction!)
if !isTablet {
self.enqueueFullscreenTransition(fullscreenTransition)
}
if speakingPeersUpdated {
var speakingPeers = speakingPeers
var updatedSpeakers: [PeerId] = []
for peerId in self.currentSpeakers {
if speakingPeers.contains(peerId) {
updatedSpeakers.append(peerId)
speakingPeers.remove(peerId)
}
}
var currentSpeakingSubtitle = ""
for peerId in Array(speakingPeers) {
updatedSpeakers.append(peerId)
if let peer = entryByPeerId[peerId]?.peer {
let displayName = speakingPeers.count == 1 ? EnginePeer(peer).displayTitle(strings: self.presentationData.strings, displayOrder: self.presentationData.nameDisplayOrder) : EnginePeer(peer).compactDisplayTitle
if currentSpeakingSubtitle.isEmpty {
currentSpeakingSubtitle.append(displayName)
} else {
currentSpeakingSubtitle.append(", \(displayName)")
}
}
}
self.currentSpeakers = updatedSpeakers
self.currentSpeakingSubtitle = currentSpeakingSubtitle.isEmpty ? nil : currentSpeakingSubtitle
self.updateTitle(transition: .immediate)
}
if case .fullscreen = self.displayMode, !self.mainStageNode.animating {
if speakingPeersUpdated {
self.mainStageNode.update(speakingPeerId: self.currentSpeakers.first)
}
} else {
self.mainStageNode.update(speakingPeerId: nil)
}
if updateLayout, let (layout, navigationHeight) = self.validLayout {
let transition = ContainedViewLayoutTransition.animated(duration: 0.4, curve: .easeInOut)
if animatingLayout {
self.animatingExpansion = true
}
self.containerLayoutUpdated(layout, navigationHeight: navigationHeight, transition: transition)
self.updateDecorationsLayout(transition: transition)
}
}
private func callStateDidReset() {
self.requestedVideoSources.removeAll()
self.filterRequestedVideoChannels(channels: [])
self.updateRequestedVideoChannels()
}
private func filterRequestedVideoChannels(channels: [PresentationGroupCallRequestedVideo]) {
var validSources = Set<String>()
for channel in channels {
validSources.insert(channel.endpointId)
if !self.requestedVideoSources.contains(channel.endpointId) {
self.requestedVideoSources.insert(channel.endpointId)
let input = (self.call as! PresentationGroupCallImpl).video(endpointId: channel.endpointId)
if let input = input, let videoView = self.videoRenderingContext.makeView(input: input, blur: false) {
let videoNode = GroupVideoNode(videoView: videoView, backdropVideoView: self.videoRenderingContext.makeView(input: input, blur: true))
self.readyVideoDisposables.set((combineLatest(videoNode.ready, .single(false) |> then(.single(true) |> delay(10.0, queue: Queue.mainQueue())))
|> deliverOnMainQueue
).start(next: { [weak self, weak videoNode] ready, timeouted in
if let strongSelf = self, let videoNode = videoNode {
Queue.mainQueue().after(0.1) {
if timeouted && !ready {
strongSelf.timeoutedEndpointIds.insert(channel.endpointId)
strongSelf.readyVideoEndpointIds.remove(channel.endpointId)
strongSelf.readyVideoEndpointIdsPromise.set(strongSelf.readyVideoEndpointIds)
strongSelf.wideVideoNodes.remove(channel.endpointId)
strongSelf.updateMembers()
} else if ready {
strongSelf.readyVideoEndpointIds.insert(channel.endpointId)
strongSelf.readyVideoEndpointIdsPromise.set(strongSelf.readyVideoEndpointIds)
strongSelf.timeoutedEndpointIds.remove(channel.endpointId)
if videoNode.aspectRatio <= 0.77 {
strongSelf.wideVideoNodes.insert(channel.endpointId)
} else {
strongSelf.wideVideoNodes.remove(channel.endpointId)
}
strongSelf.updateMembers()
if let (layout, _) = strongSelf.validLayout, case .compact = layout.metrics.widthClass {
if let interaction = strongSelf.itemInteraction {
loop: for i in 0 ..< strongSelf.currentFullscreenEntries.count {
let entry = strongSelf.currentFullscreenEntries[i]
switch entry {
case let .peer(peerEntry, _):
if peerEntry.effectiveVideoEndpointId == channel.endpointId {
let presentationData = strongSelf.presentationData.withUpdated(theme: strongSelf.darkTheme)
strongSelf.fullscreenListNode.transaction(deleteIndices: [], insertIndicesAndItems: [], updateIndicesAndItems: [ListViewUpdateItem(index: i, previousIndex: i, item: entry.fullscreenItem(context: strongSelf.context, presentationData: presentationData, interaction: interaction), directionHint: nil)], options: [.Synchronous], updateOpaqueState: nil)
break loop
}
default:
break
}
}
}
}
}
}
}
}), forKey: channel.endpointId)
self.videoNodes[channel.endpointId] = videoNode
if let _ = self.validLayout {
self.updateMembers()
}
}
/*self.call.makeIncomingVideoView(endpointId: channel.endpointId, requestClone: GroupVideoNode.useBlurTransparency, completion: { [weak self] videoView, backdropVideoView in
Queue.mainQueue().async {
guard let strongSelf = self, let videoView = videoView else {
return
}
let videoNode = GroupVideoNode(videoView: videoView, backdropVideoView: backdropVideoView)
strongSelf.readyVideoDisposables.set((combineLatest(videoNode.ready, .single(false) |> then(.single(true) |> delay(10.0, queue: Queue.mainQueue())))
|> deliverOnMainQueue
).start(next: { [weak self, weak videoNode] ready, timeouted in
if let strongSelf = self, let videoNode = videoNode {
Queue.mainQueue().after(0.1) {
if timeouted && !ready {
strongSelf.timeoutedEndpointIds.insert(channel.endpointId)
strongSelf.readyVideoEndpointIds.remove(channel.endpointId)
strongSelf.readyVideoEndpointIdsPromise.set(strongSelf.readyVideoEndpointIds)
strongSelf.wideVideoNodes.remove(channel.endpointId)
strongSelf.updateMembers()
} else if ready {
strongSelf.readyVideoEndpointIds.insert(channel.endpointId)
strongSelf.readyVideoEndpointIdsPromise.set(strongSelf.readyVideoEndpointIds)
strongSelf.timeoutedEndpointIds.remove(channel.endpointId)
if videoNode.aspectRatio <= 0.77 {
strongSelf.wideVideoNodes.insert(channel.endpointId)
} else {
strongSelf.wideVideoNodes.remove(channel.endpointId)
}
strongSelf.updateMembers()
if let (layout, _) = strongSelf.validLayout, case .compact = layout.metrics.widthClass {
if let interaction = strongSelf.itemInteraction {
loop: for i in 0 ..< strongSelf.currentFullscreenEntries.count {
let entry = strongSelf.currentFullscreenEntries[i]
switch entry {
case let .peer(peerEntry, _):
if peerEntry.effectiveVideoEndpointId == channel.endpointId {
let presentationData = strongSelf.presentationData.withUpdated(theme: strongSelf.darkTheme)
strongSelf.fullscreenListNode.transaction(deleteIndices: [], insertIndicesAndItems: [], updateIndicesAndItems: [ListViewUpdateItem(index: i, previousIndex: i, item: entry.fullscreenItem(context: strongSelf.context, presentationData: presentationData, interaction: interaction), directionHint: nil)], options: [.Synchronous], updateOpaqueState: nil)
break loop
}
default:
break
}
}
}
}
}
}
}
}), forKey: channel.endpointId)
strongSelf.videoNodes[channel.endpointId] = videoNode
if let _ = strongSelf.validLayout {
strongSelf.updateMembers()
}
}
})*/
}
}
var removeRequestedVideoSources: [String] = []
for source in self.requestedVideoSources {
if !validSources.contains(source) {
removeRequestedVideoSources.append(source)
}
}
for source in removeRequestedVideoSources {
self.requestedVideoSources.remove(source)
}
for (videoEndpointId, _) in self.videoNodes {
if !validSources.contains(videoEndpointId) {
self.videoNodes[videoEndpointId] = nil
self.videoOrder.removeAll(where: { $0 == videoEndpointId })
self.readyVideoEndpointIds.remove(videoEndpointId)
self.readyVideoEndpointIdsPromise.set(self.readyVideoEndpointIds)
self.readyVideoDisposables.set(nil, forKey: videoEndpointId)
}
}
}
private func updateMainVideo(waitForFullSize: Bool, entries: [ListEntry]? = nil, updateMembers: Bool = true, force: Bool = false, completion: (() -> Void)? = nil) {
let effectiveMainSpeaker = self.currentForcedSpeaker ?? self.currentDominantSpeaker.flatMap { ($0.0, $0.1) }
guard effectiveMainSpeaker?.0 != self.effectiveSpeaker?.0 || effectiveMainSpeaker?.1 != self.effectiveSpeaker?.1 || force else {
return
}
let currentEntries = entries ?? self.currentFullscreenEntries
var effectiveSpeaker: (PeerId, String?, Bool, Bool, Bool)? = nil
var anySpeakerWithVideo: (PeerId, String?, Bool, Bool, Bool)? = nil
var anySpeaker: (PeerId, Bool)? = nil
if let (peerId, preferredVideoEndpointId) = effectiveMainSpeaker {
for entry in currentEntries {
switch entry {
case let .peer(peer, _):
if peer.peer.id == peerId {
if let preferredVideoEndpointId = preferredVideoEndpointId, peer.videoEndpointId == preferredVideoEndpointId || peer.presentationEndpointId == preferredVideoEndpointId {
var isPaused = false
if peer.presentationEndpointId != nil && preferredVideoEndpointId == peer.presentationEndpointId {
isPaused = peer.presentationPaused
} else if peer.videoEndpointId != nil && preferredVideoEndpointId == peer.videoEndpointId {
isPaused = peer.videoPaused
}
effectiveSpeaker = (peerId, preferredVideoEndpointId, peer.isMyPeer, peer.presentationEndpointId != nil && preferredVideoEndpointId == peer.presentationEndpointId, isPaused)
} else {
var isPaused = false
if peer.effectiveVideoEndpointId != nil && peer.effectiveVideoEndpointId == peer.presentationEndpointId {
isPaused = peer.presentationPaused
} else if peer.effectiveVideoEndpointId != nil && peer.effectiveVideoEndpointId == peer.videoEndpointId {
isPaused = peer.videoPaused
}
effectiveSpeaker = (peerId, peer.effectiveVideoEndpointId, peer.isMyPeer, peer.presentationEndpointId != nil && peer.effectiveVideoEndpointId == peer.presentationEndpointId, isPaused)
}
} else if anySpeakerWithVideo == nil, let videoEndpointId = peer.effectiveVideoEndpointId {
var isPaused = false
if videoEndpointId == peer.presentationEndpointId {
isPaused = peer.presentationPaused
} else if videoEndpointId == peer.videoEndpointId {
isPaused = peer.videoPaused
}
anySpeakerWithVideo = (peer.peer.id, videoEndpointId, peer.isMyPeer, peer.presentationEndpointId != nil && videoEndpointId == peer.presentationEndpointId, isPaused)
} else if anySpeaker == nil {
anySpeaker = (peer.peer.id, peer.isMyPeer)
}
default:
break
}
}
}
if effectiveSpeaker == nil {
self.currentForcedSpeaker = nil
effectiveSpeaker = anySpeakerWithVideo ?? anySpeaker.flatMap { ($0.0, nil, $0.1, false, false) }
if let (peerId, videoEndpointId, _, _, _) = effectiveSpeaker {
self.currentDominantSpeaker = (peerId, videoEndpointId, CACurrentMediaTime())
} else {
self.currentDominantSpeaker = nil
}
}
self.effectiveSpeaker = effectiveSpeaker
if updateMembers {
self.updateMembers(maybeUpdateVideo: false, force: force)
}
var waitForFullSize = waitForFullSize
var isReady = false
if let (_, maybeVideoEndpointId, _, _, _) = effectiveSpeaker, let videoEndpointId = maybeVideoEndpointId {
isReady = true
if !self.readyVideoEndpointIds.contains(videoEndpointId) {
isReady = false
if entries == nil {
waitForFullSize = false
}
}
}
self.mainStageNode.update(peer: effectiveSpeaker, isReady: isReady, waitForFullSize: waitForFullSize, completion: {
completion?()
})
}
private func updateRequestedVideoChannels() {
Queue.mainQueue().after(0.3) {
let enableVideo = self.appIsActive && self.visibility
self.call.setRequestedVideoList(items: enableVideo ? self.requestedVideoChannels : [])
self.filterRequestedVideoChannels(channels: self.requestedVideoChannels)
}
}
override func gestureRecognizerShouldBegin(_ gestureRecognizer: UIGestureRecognizer) -> Bool {
if gestureRecognizer is UILongPressGestureRecognizer {
return !self.isScheduling
} else if gestureRecognizer is DirectionalPanGestureRecognizer {
if self.mainStageNode.animating || self.animatingMainStage {
return false
}
let bottomPanelLocation = gestureRecognizer.location(in: self.bottomPanelNode.view)
let containerLocation = gestureRecognizer.location(in: self.contentContainer.view)
let mainStageLocation = gestureRecognizer.location(in: self.mainStageNode.view)
if self.isLandscape && self.mainStageContainerNode.isUserInteractionEnabled && mainStageLocation.x > self.mainStageNode.frame.width - 80.0 {
return false
}
if self.audioButton.frame.contains(bottomPanelLocation) || (!self.cameraButton.isHidden && self.cameraButton.frame.contains(bottomPanelLocation)) || self.leaveButton.frame.contains(bottomPanelLocation) || self.pickerView?.frame.contains(containerLocation) == true || (self.mainStageContainerNode.isUserInteractionEnabled && (mainStageLocation.y < 44.0 || mainStageLocation.y > self.mainStageNode.frame.height - 100.0)) {
return false
}
}
return true
}
func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldRecognizeSimultaneouslyWith otherGestureRecognizer: UIGestureRecognizer) -> Bool {
if gestureRecognizer is UIPanGestureRecognizer && otherGestureRecognizer is UIPanGestureRecognizer {
return true
}
return false
}
private var isPanningList = false
@objc func panGesture(_ recognizer: UIPanGestureRecognizer) {
guard let (layout, _) = self.validLayout else {
return
}
let contentOffset = self.listNode.visibleContentOffset()
switch recognizer.state {
case .began:
let topInset: CGFloat
if case .regular = layout.metrics.widthClass {
topInset = 0.0
} else if self.isExpanded {
topInset = 0.0
} else if let currentTopInset = self.topInset {
topInset = currentTopInset
} else {
topInset = self.listNode.frame.height
}
self.panGestureArguments = (topInset, 0.0)
self.controller?.dismissAllTooltips()
let location = recognizer.location(in: self.listContainer.view)
let isPanningList: Bool
if self.listNode.frame.contains(location) {
if case let .known(value) = contentOffset, value <= 0.5 {
isPanningList = false
} else {
isPanningList = true
}
} else {
isPanningList = false
}
self.isPanningList = isPanningList
if case .fullscreen = self.displayMode, case .compact = layout.metrics.widthClass {
self.isPanning = true
self.mainStageBackgroundNode.alpha = 0.0
self.mainStageBackgroundNode.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.4)
self.mainStageNode.setControlsHidden(true, animated: true)
self.fullscreenListNode.alpha = 0.0
self.fullscreenListNode.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.1, completion: { [weak self] finished in
self?.attachTileVideos()
self?.fullscreenListContainer.subnodeTransform = CATransform3DIdentity
})
self.listContainer.transform = CATransform3DMakeScale(0.86, 0.86, 1.0)
self.contentContainer.insertSubnode(self.mainStageContainerNode, aboveSubnode: self.bottomPanelNode)
}
case .changed:
var translation = recognizer.translation(in: self.contentContainer.view).y
if self.isScheduled && translation < 0.0 {
return
}
var translateBounds = false
if case .regular = layout.metrics.widthClass {
if !self.isPanningList {
translateBounds = true
}
} else {
switch self.displayMode {
case let .modal(isExpanded, previousIsFilled):
var topInset: CGFloat = 0.0
if let (currentTopInset, currentPanOffset) = self.panGestureArguments {
topInset = currentTopInset
if case let .known(value) = contentOffset, value <= 0.5 {
} else {
translation = currentPanOffset
if self.isExpanded {
recognizer.setTranslation(CGPoint(), in: self.contentContainer.view)
}
}
self.panGestureArguments = (currentTopInset, translation)
}
let currentOffset = topInset + translation
var isFilled = previousIsFilled
if currentOffset < 20.0 {
isFilled = true
} else if currentOffset > 40.0 {
isFilled = false
}
if isFilled != previousIsFilled {
self.displayMode = .modal(isExpanded: isExpanded, isFilled: isFilled)
self.updateDecorationsColors()
}
if self.isExpanded {
} else {
if currentOffset > 0.0 {
self.listNode.scroller.panGestureRecognizer.setTranslation(CGPoint(), in: self.listNode.scroller)
}
}
case .fullscreen:
if abs(translation) > 32.0 {
if self.fullscreenListNode.layer.animationKeys()?.contains("opacity") == true {
self.fullscreenListNode.layer.removeAllAnimations()
}
}
var bounds = self.mainStageContainerNode.bounds
bounds.origin.y = -translation
self.mainStageContainerNode.bounds = bounds
var backgroundFrame = self.mainStageNode.frame
backgroundFrame.origin.y += -translation
self.mainStageBackgroundNode.frame = backgroundFrame
self.fullscreenListContainer.subnodeTransform = CATransform3DMakeTranslation(0.0, translation, 0.0)
}
translateBounds = !self.isExpanded
}
if let (layout, navigationHeight) = self.validLayout {
self.containerLayoutUpdated(layout, navigationHeight: navigationHeight, transition: .immediate)
self.updateDecorationsLayout(transition: .immediate)
}
if translateBounds {
var bounds = self.contentContainer.bounds
bounds.origin.y = -translation
bounds.origin.y = min(0.0, bounds.origin.y)
self.contentContainer.bounds = bounds
}
case .ended:
let translation = recognizer.translation(in: self.contentContainer.view)
var velocity = recognizer.velocity(in: self.contentContainer.view)
if self.isScheduled && (translation.y < 0.0 || velocity.y < 0.0) {
return
}
if case let .known(value) = contentOffset, value > 0.0 {
velocity = CGPoint()
} else if case .unknown = contentOffset {
velocity = CGPoint()
}
var bounds = self.contentContainer.bounds
bounds.origin.y = -translation.y
bounds.origin.y = min(0.0, bounds.origin.y)
let offset: CGFloat
if let (inset, panOffset) = self.panGestureArguments {
offset = inset + panOffset
} else {
offset = 0.0
}
let topInset: CGFloat
if let currentTopInset = self.topInset {
topInset = currentTopInset
} else {
topInset = self.listNode.frame.height
}
if case .fullscreen = self.displayMode, case .compact = layout.metrics.widthClass {
self.panGestureArguments = nil
self.fullscreenListContainer.subnodeTransform = CATransform3DIdentity
if abs(translation.y) > 100.0 || abs(velocity.y) > 300.0 {
self.mainStageBackgroundNode.layer.removeAllAnimations()
self.currentForcedSpeaker = nil
self.updateDisplayMode(.modal(isExpanded: true, isFilled: true), fromPan: true)
self.effectiveSpeaker = nil
} else {
self.isPanning = false
self.mainStageBackgroundNode.alpha = 1.0
self.mainStageBackgroundNode.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.15, completion: { [weak self] _ in
self?.attachFullscreenVideos()
})
self.mainStageNode.setControlsHidden(false, animated: true, delay: 0.15)
self.fullscreenListNode.alpha = 1.0
self.fullscreenListNode.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.2, delay: 0.15)
var bounds = self.mainStageContainerNode.bounds
let previousBounds = bounds
bounds.origin.y = 0.0
self.mainStageContainerNode.bounds = bounds
self.mainStageContainerNode.layer.animateBounds(from: previousBounds, to: self.mainStageContainerNode.bounds, duration: 0.2, timingFunction: kCAMediaTimingFunctionSpring, completion: { [weak self] _ in
if let strongSelf = self {
strongSelf.listContainer.transform = CATransform3DIdentity
strongSelf.contentContainer.insertSubnode(strongSelf.mainStageContainerNode, belowSubnode: strongSelf.transitionContainerNode)
strongSelf.updateMembers()
}
})
}
} else if case .modal(true, _) = self.displayMode, case .compact = layout.metrics.widthClass {
self.panGestureArguments = nil
if velocity.y > 300.0 || offset > topInset / 2.0 {
self.displayMode = .modal(isExpanded: false, isFilled: false)
self.updateDecorationsColors()
self.animatingExpansion = true
self.listNode.scroller.setContentOffset(CGPoint(), animated: false)
let distance: CGFloat
if let topInset = self.topInset {
distance = topInset - offset
} else {
distance = 0.0
}
let initialVelocity: CGFloat = distance.isZero ? 0.0 : abs(velocity.y / distance)
let transition = ContainedViewLayoutTransition.animated(duration: 0.45, curve: .customSpring(damping: 124.0, initialVelocity: initialVelocity))
if let (layout, navigationHeight) = self.validLayout {
self.containerLayoutUpdated(layout, navigationHeight: navigationHeight, transition: transition)
}
self.updateDecorationsLayout(transition: transition, completion: {
self.animatingExpansion = false
})
} else {
self.displayMode = .modal(isExpanded: true, isFilled: true)
self.updateDecorationsColors()
self.animatingExpansion = true
if let (layout, navigationHeight) = self.validLayout {
self.containerLayoutUpdated(layout, navigationHeight: navigationHeight, transition: .animated(duration: 0.3, curve: .easeInOut))
}
self.updateDecorationsLayout(transition: .animated(duration: 0.3, curve: .easeInOut), completion: {
self.animatingExpansion = false
})
}
} else {
self.panGestureArguments = nil
var dismissing = false
if case .regular = layout.metrics.widthClass, self.isPanningList {
} else {
if bounds.minY < -60 || (bounds.minY < 0.0 && velocity.y > 300.0) {
if self.isScheduling {
self.dismissScheduled()
dismissing = true
} else if case .regular = layout.metrics.widthClass {
self.controller?.dismiss(closing: false, manual: true)
dismissing = true
} else {
if case .fullscreen = self.displayMode {
} else {
self.controller?.dismiss(closing: false, manual: true)
dismissing = true
}
}
} else if !self.isScheduling && (velocity.y < -300.0 || offset < topInset / 2.0) {
if velocity.y > -2200.0 && !self.isFullscreen {
DispatchQueue.main.async {
self.listNode.transaction(deleteIndices: [], insertIndicesAndItems: [], updateIndicesAndItems: [], options: [.Synchronous, .LowLatency], scrollToItem: ListViewScrollToItem(index: 0, position: .top(0.0), animated: true, curve: .Default(duration: nil), directionHint: .Up), updateSizeAndInsets: nil, stationaryItemRange: nil, updateOpaqueState: nil, completion: { _ in })
}
}
let initialVelocity: CGFloat = offset.isZero ? 0.0 : abs(velocity.y / offset)
let transition = ContainedViewLayoutTransition.animated(duration: 0.45, curve: .customSpring(damping: 124.0, initialVelocity: initialVelocity))
if case .modal = self.displayMode {
self.displayMode = .modal(isExpanded: true, isFilled: true)
}
self.updateDecorationsColors()
self.animatingExpansion = true
if let (layout, navigationHeight) = self.validLayout {
self.containerLayoutUpdated(layout, navigationHeight: navigationHeight, transition: transition)
}
self.updateDecorationsLayout(transition: transition, completion: {
self.animatingExpansion = false
})
} else if !self.isScheduling {
self.updateDecorationsColors()
self.animatingExpansion = true
self.listNode.scroller.setContentOffset(CGPoint(), animated: false)
if let (layout, navigationHeight) = self.validLayout {
self.containerLayoutUpdated(layout, navigationHeight: navigationHeight, transition: .animated(duration: 0.3, curve: .easeInOut))
}
self.updateDecorationsLayout(transition: .animated(duration: 0.3, curve: .easeInOut), completion: {
self.animatingExpansion = false
})
}
}
if !dismissing {
var bounds = self.contentContainer.bounds
let previousBounds = bounds
bounds.origin.y = 0.0
self.contentContainer.bounds = bounds
self.contentContainer.layer.animateBounds(from: previousBounds, to: self.contentContainer.bounds, duration: 0.3, timingFunction: CAMediaTimingFunctionName.easeInEaseOut.rawValue)
}
}
case .cancelled:
self.panGestureArguments = nil
let previousBounds = self.contentContainer.bounds
var bounds = self.contentContainer.bounds
bounds.origin.y = 0.0
self.contentContainer.bounds = bounds
self.contentContainer.layer.animateBounds(from: previousBounds, to: self.contentContainer.bounds, duration: 0.3, timingFunction: CAMediaTimingFunctionName.easeInEaseOut.rawValue)
if let (layout, navigationHeight) = self.validLayout {
self.containerLayoutUpdated(layout, navigationHeight: navigationHeight, transition: .animated(duration: 0.3, curve: .easeInOut))
}
self.updateDecorationsLayout(transition: .animated(duration: 0.3, curve: .easeInOut), completion: {
self.animatingExpansion = false
})
if case .fullscreen = self.displayMode, case .regular = layout.metrics.widthClass {
self.fullscreenListContainer.subnodeTransform = CATransform3DIdentity
self.isPanning = false
self.mainStageBackgroundNode.alpha = 1.0
self.mainStageBackgroundNode.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.15, completion: { [weak self] _ in
self?.attachFullscreenVideos()
})
self.mainStageNode.setControlsHidden(false, animated: true, delay: 0.15)
self.fullscreenListNode.alpha = 1.0
self.fullscreenListNode.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.2, delay: 0.15)
var bounds = self.mainStageContainerNode.bounds
let previousBounds = bounds
bounds.origin.y = 0.0
self.mainStageContainerNode.bounds = bounds
self.mainStageContainerNode.layer.animateBounds(from: previousBounds, to: self.mainStageContainerNode.bounds, duration: 0.2, timingFunction: kCAMediaTimingFunctionSpring, completion: { [weak self] _ in
if let strongSelf = self {
strongSelf.contentContainer.insertSubnode(strongSelf.mainStageContainerNode, belowSubnode: strongSelf.transitionContainerNode)
strongSelf.updateMembers()
strongSelf.listContainer.transform = CATransform3DIdentity
}
})
}
default:
break
}
}
override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
let result = super.hitTest(point, with: event)
if result === self.topPanelNode.view {
return self.view
}
if result === self.bottomPanelNode.view {
return self.view
}
if !self.bounds.contains(point) {
return nil
}
if point.y < self.topPanelNode.frame.minY {
return self.dimNode.view
}
return result
}
fileprivate func scrollToTop() {
if self.isExpanded {
self.listNode.transaction(deleteIndices: [], insertIndicesAndItems: [], updateIndicesAndItems: [], options: [.Synchronous, .LowLatency], scrollToItem: ListViewScrollToItem(index: 0, position: .top(0.0), animated: true, curve: .Default(duration: nil), directionHint: .Up), updateSizeAndInsets: nil, stationaryItemRange: nil, updateOpaqueState: nil, completion: { _ in })
}
}
private func openTitleEditing() {
let _ = (self.context.account.postbox.loadedPeerWithId(self.call.peerId)
|> deliverOnMainQueue).start(next: { [weak self] chatPeer in
guard let strongSelf = self else {
return
}
let initialTitle = strongSelf.callState?.title ?? ""
let title: String
let text: String
if let channel = strongSelf.peer as? TelegramChannel, case .broadcast = channel.info {
title = strongSelf.presentationData.strings.LiveStream_EditTitle
text = strongSelf.presentationData.strings.LiveStream_EditTitleText
} else {
title = strongSelf.presentationData.strings.VoiceChat_EditTitle
text = strongSelf.presentationData.strings.VoiceChat_EditTitleText
}
let controller = voiceChatTitleEditController(sharedContext: strongSelf.context.sharedContext, account: strongSelf.context.account, forceTheme: strongSelf.darkTheme, title: title, text: text, placeholder: EnginePeer(chatPeer).displayTitle(strings: strongSelf.presentationData.strings, displayOrder: strongSelf.presentationData.nameDisplayOrder), value: initialTitle, maxLength: 40, apply: { title in
if let strongSelf = self, let title = title, title != initialTitle {
strongSelf.call.updateTitle(title)
let text: String
if let channel = strongSelf.peer as? TelegramChannel, case .broadcast = channel.info {
text = title.isEmpty ? strongSelf.presentationData.strings.LiveStream_EditTitleRemoveSuccess : strongSelf.presentationData.strings.LiveStream_EditTitleSuccess(title).string
} else {
text = title.isEmpty ? strongSelf.presentationData.strings.VoiceChat_EditTitleRemoveSuccess : strongSelf.presentationData.strings.VoiceChat_EditTitleSuccess(title).string
}
strongSelf.presentUndoOverlay(content: .voiceChatFlag(text: text), action: { _ in return false })
}
})
strongSelf.controller?.present(controller, in: .window(.root))
})
}
private func openAvatarForEditing(fromGallery: Bool = false, completion: @escaping () -> Void = {}) {
guard let peerId = self.callState?.myPeerId else {
return
}
let _ = (self.context.engine.data.get(
TelegramEngine.EngineData.Item.Peer.Peer(id: peerId),
TelegramEngine.EngineData.Item.Configuration.SearchBots()
)
|> deliverOnMainQueue).start(next: { [weak self] peer, searchBotsConfiguration in
guard let strongSelf = self, let peer = peer else {
return
}
let presentationData = strongSelf.presentationData
let legacyController = LegacyController(presentation: .custom, theme: strongSelf.darkTheme)
legacyController.statusBar.statusBarStyle = .Ignore
let emptyController = LegacyEmptyController(context: legacyController.context)!
let navigationController = makeLegacyNavigationController(rootController: emptyController)
navigationController.setNavigationBarHidden(true, animated: false)
navigationController.navigationBar.transform = CGAffineTransform(translationX: -1000.0, y: 0.0)
legacyController.bind(controller: navigationController)
strongSelf.view.endEditing(true)
strongSelf.controller?.present(legacyController, in: .window(.root))
var hasPhotos = false
if !peer.profileImageRepresentations.isEmpty {
hasPhotos = true
}
let mixin = TGMediaAvatarMenuMixin(context: legacyController.context, parentController: emptyController, hasSearchButton: true, hasDeleteButton: hasPhotos && !fromGallery, hasViewButton: false, personalPhoto: peerId.namespace == Namespaces.Peer.CloudUser, isVideo: false, saveEditedPhotos: false, saveCapturedMedia: false, signup: false, forum: false, title: nil, isSuggesting: false)!
mixin.forceDark = true
mixin.stickersContext = LegacyPaintStickersContext(context: strongSelf.context)
let _ = strongSelf.currentAvatarMixin.swap(mixin)
mixin.requestSearchController = { [weak self] assetsController in
guard let strongSelf = self else {
return
}
let controller = WebSearchController(context: strongSelf.context, peer: peer, chatLocation: nil, configuration: searchBotsConfiguration, mode: .avatar(initialQuery: peer.id.namespace == Namespaces.Peer.CloudUser ? nil : peer.displayTitle(strings: presentationData.strings, displayOrder: presentationData.nameDisplayOrder), completion: { [weak self] result in
assetsController?.dismiss()
self?.updateProfilePhoto(result)
}))
controller.navigationPresentation = .modal
strongSelf.controller?.push(controller)
if fromGallery {
completion()
}
}
mixin.didFinishWithImage = { [weak self] image in
if let image = image {
completion()
self?.updateProfilePhoto(image)
}
}
mixin.didFinishWithVideo = { [weak self] image, asset, adjustments in
if let image = image, let asset = asset {
completion()
self?.updateProfileVideo(image, asset: asset, adjustments: adjustments)
}
}
mixin.didFinishWithDelete = {
guard let strongSelf = self else {
return
}
let proceed = {
let _ = strongSelf.currentAvatarMixin.swap(nil)
let postbox = strongSelf.context.account.postbox
strongSelf.updateAvatarDisposable.set((strongSelf.context.engine.peers.updatePeerPhoto(peerId: peerId, photo: nil, mapResourceToAvatarSizes: { resource, representations in
return mapResourceToAvatarSizes(postbox: postbox, resource: resource, representations: representations)
})
|> deliverOnMainQueue).start())
}
let actionSheet = ActionSheetController(presentationData: presentationData.withUpdated(theme: strongSelf.darkTheme))
let items: [ActionSheetItem] = [
ActionSheetButtonItem(title: presentationData.strings.Settings_RemoveConfirmation, color: .destructive, action: { [weak actionSheet] in
actionSheet?.dismissAnimated()
proceed()
})
]
actionSheet.setItemGroups([
ActionSheetItemGroup(items: items),
ActionSheetItemGroup(items: [
ActionSheetButtonItem(title: presentationData.strings.Common_Cancel, color: .accent, font: .bold, action: { [weak actionSheet] in
actionSheet?.dismissAnimated()
})
])
])
strongSelf.controller?.present(actionSheet, in: .window(.root))
}
mixin.didDismiss = { [weak legacyController] in
guard let strongSelf = self else {
return
}
let _ = strongSelf.currentAvatarMixin.swap(nil)
legacyController?.dismiss()
}
let menuController = mixin.present()
if let menuController = menuController {
menuController.customRemoveFromParentViewController = { [weak legacyController] in
legacyController?.dismiss()
}
}
})
}
private func updateProfilePhoto(_ image: UIImage) {
guard let data = image.jpegData(compressionQuality: 0.6), let peerId = self.callState?.myPeerId else {
return
}
let resource = LocalFileMediaResource(fileId: Int64.random(in: Int64.min ... Int64.max))
self.call.account.postbox.mediaBox.storeResourceData(resource.id, data: data)
let representation = TelegramMediaImageRepresentation(dimensions: PixelDimensions(width: 640, height: 640), resource: resource, progressiveSizes: [], immediateThumbnailData: nil, hasVideo: false, isPersonal: false)
self.currentUpdatingAvatar = representation
self.updateAvatarPromise.set(.single((representation, 0.0)))
let postbox = self.call.account.postbox
let signal = peerId.namespace == Namespaces.Peer.CloudUser ? self.call.accountContext.engine.accountData.updateAccountPhoto(resource: resource, videoResource: nil, videoStartTimestamp: nil, markup: nil, mapResourceToAvatarSizes: { resource, representations in
return mapResourceToAvatarSizes(postbox: postbox, resource: resource, representations: representations)
}) : self.call.accountContext.engine.peers.updatePeerPhoto(peerId: peerId, photo: self.call.accountContext.engine.peers.uploadedPeerPhoto(resource: resource), mapResourceToAvatarSizes: { resource, representations in
return mapResourceToAvatarSizes(postbox: postbox, resource: resource, representations: representations)
})
self.updateAvatarDisposable.set((signal
|> deliverOnMainQueue).start(next: { [weak self] result in
guard let strongSelf = self else {
return
}
switch result {
case .complete:
strongSelf.updateAvatarPromise.set(.single(nil))
case let .progress(value):
strongSelf.updateAvatarPromise.set(.single((representation, value)))
}
}))
self.updateMembers()
}
private func updateProfileVideo(_ image: UIImage, asset: Any?, adjustments: TGVideoEditAdjustments?) {
guard let data = image.jpegData(compressionQuality: 0.6), let peerId = self.callState?.myPeerId else {
return
}
let photoResource = LocalFileMediaResource(fileId: Int64.random(in: Int64.min ... Int64.max))
self.context.account.postbox.mediaBox.storeResourceData(photoResource.id, data: data)
let representation = TelegramMediaImageRepresentation(dimensions: PixelDimensions(width: 640, height: 640), resource: photoResource, progressiveSizes: [], immediateThumbnailData: nil, hasVideo: false, isPersonal: false)
self.currentUpdatingAvatar = representation
self.updateAvatarPromise.set(.single((representation, 0.0)))
var videoStartTimestamp: Double? = nil
if let adjustments = adjustments, adjustments.videoStartValue > 0.0 {
videoStartTimestamp = adjustments.videoStartValue - adjustments.trimStartValue
}
let context = self.context
let account = self.context.account
let signal = Signal<TelegramMediaResource, UploadPeerPhotoError> { [weak self] subscriber in
let entityRenderer: LegacyPaintEntityRenderer? = adjustments.flatMap { adjustments in
if let paintingData = adjustments.paintingData, paintingData.hasAnimation {
return LegacyPaintEntityRenderer(postbox: account.postbox, adjustments: adjustments)
} else {
return nil
}
}
let tempFile = EngineTempBox.shared.tempFile(fileName: "video.mp4")
let uploadInterface = LegacyLiveUploadInterface(context: context)
let signal: SSignal
if let url = asset as? URL, url.absoluteString.hasSuffix(".jpg"), let data = try? Data(contentsOf: url, options: [.mappedRead]), let image = UIImage(data: data), let entityRenderer = entityRenderer {
let durationSignal: SSignal = SSignal(generator: { subscriber in
let disposable = (entityRenderer.duration()).start(next: { duration in
subscriber.putNext(duration)
subscriber.putCompletion()
})
return SBlockDisposable(block: {
disposable.dispose()
})
})
signal = durationSignal.map(toSignal: { duration -> SSignal in
if let duration = duration as? Double {
return TGMediaVideoConverter.renderUIImage(image, duration: duration, adjustments: adjustments, path: tempFile.path, watcher: nil, entityRenderer: entityRenderer)!
} else {
return SSignal.single(nil)
}
})
} else if let asset = asset as? AVAsset {
signal = TGMediaVideoConverter.convert(asset, adjustments: adjustments, path: tempFile.path, watcher: uploadInterface, entityRenderer: entityRenderer)!
} else {
signal = SSignal.complete()
}
let signalDisposable = signal.start(next: { next in
if let result = next as? TGMediaVideoConversionResult {
if let image = result.coverImage, let data = image.jpegData(compressionQuality: 0.7) {
account.postbox.mediaBox.storeResourceData(photoResource.id, data: data)
}
if let timestamp = videoStartTimestamp {
videoStartTimestamp = max(0.0, min(timestamp, result.duration - 0.05))
}
var value = stat()
if stat(result.fileURL.path, &value) == 0 {
if let data = try? Data(contentsOf: result.fileURL) {
let resource: TelegramMediaResource
if let liveUploadData = result.liveUploadData as? LegacyLiveUploadInterfaceResult {
resource = LocalFileMediaResource(fileId: liveUploadData.id)
} else {
resource = LocalFileMediaResource(fileId: Int64.random(in: Int64.min ... Int64.max))
}
account.postbox.mediaBox.storeResourceData(resource.id, data: data, synchronous: true)
subscriber.putNext(resource)
EngineTempBox.shared.dispose(tempFile)
}
}
subscriber.putCompletion()
} else if let strongSelf = self, let progress = next as? NSNumber {
Queue.mainQueue().async {
strongSelf.updateAvatarPromise.set(.single((representation, Float(truncating: progress) * 0.25)))
}
}
}, error: { _ in
}, completed: nil)
let disposable = ActionDisposable {
signalDisposable?.dispose()
}
return ActionDisposable {
disposable.dispose()
}
}
self.updateAvatarDisposable.set((signal
|> mapToSignal { videoResource -> Signal<UpdatePeerPhotoStatus, UploadPeerPhotoError> in
if peerId.namespace == Namespaces.Peer.CloudUser {
return context.engine.accountData.updateAccountPhoto(resource: photoResource, videoResource: videoResource, videoStartTimestamp: videoStartTimestamp, markup: nil, mapResourceToAvatarSizes: { resource, representations in
return mapResourceToAvatarSizes(postbox: account.postbox, resource: resource, representations: representations)
})
} else {
return context.engine.peers.updatePeerPhoto(peerId: peerId, photo: context.engine.peers.uploadedPeerPhoto(resource: photoResource), video: context.engine.peers.uploadedPeerVideo(resource: videoResource) |> map(Optional.init), videoStartTimestamp: videoStartTimestamp, mapResourceToAvatarSizes: { resource, representations in
return mapResourceToAvatarSizes(postbox: account.postbox, resource: resource, representations: representations)
})
}
}
|> deliverOnMainQueue).start(next: { [weak self] result in
guard let strongSelf = self else {
return
}
switch result {
case .complete:
strongSelf.updateAvatarPromise.set(.single(nil))
case let .progress(value):
strongSelf.updateAvatarPromise.set(.single((representation, 0.25 + value * 0.75)))
}
}))
}
private func displayUnmuteTooltip() {
guard let (layout, _) = self.validLayout else {
return
}
let location = self.actionButton.view.convert(self.actionButton.bounds, to: self.view).center
var point = CGRect(origin: CGPoint(x: location.x - 5.0, y: location.y - 5.0 - 68.0), size: CGSize(width: 10.0, height: 10.0))
var position: TooltipScreen.ArrowPosition = .bottom
if case .compact = layout.metrics.widthClass {
if self.isLandscape {
point.origin.x = location.x - 5.0 - 36.0
point.origin.y = location.y - 5.0
position = .right
} else if case .fullscreen = self.displayMode {
point.origin.y += 32.0
}
}
self.controller?.present(TooltipScreen(account: self.context.account, sharedContext: self.context.sharedContext, text: .plain(text: self.presentationData.strings.VoiceChat_UnmuteSuggestion), style: .gradient(UIColor(rgb: 0x1d446c), UIColor(rgb: 0x193e63)), icon: nil, location: .point(point, position), displayDuration: .custom(8.0), shouldDismissOnTouch: { _, _ in
return .dismiss(consume: false)
}), in: .window(.root))
}
private var isScheduled: Bool {
return self.isScheduling || self.callState?.scheduleTimestamp != nil
}
private func attachFullscreenVideos() {
guard let (layout, _) = self.validLayout, case .compact = layout.metrics.widthClass else {
return
}
var verticalItemNodes: [String: ASDisplayNode] = [:]
self.listNode.forEachItemNode { itemNode in
if let itemNode = itemNode as? VoiceChatTilesGridItemNode {
for tileNode in itemNode.tileNodes {
if let item = tileNode.item {
verticalItemNodes[String(item.peer.id.toInt64()) + "_" + item.videoEndpointId] = tileNode
}
if tileNode.item?.peer.id == self.effectiveSpeaker?.0 && tileNode.item?.videoEndpointId == self.effectiveSpeaker?.1 {
tileNode.isHidden = false
}
}
}
}
self.fullscreenListNode.forEachItemNode { itemNode in
if let itemNode = itemNode as? VoiceChatFullscreenParticipantItemNode, let item = itemNode.item {
let otherItemNode = verticalItemNodes[String(item.peer.id.toInt64()) + "_" + (item.videoEndpointId ?? "")]
itemNode.transitionIn(from: otherItemNode)
}
}
}
private func attachTileVideos() {
var fullscreenItemNodes: [String: VoiceChatFullscreenParticipantItemNode] = [:]
var tileNodes: [VoiceChatTileItemNode] = []
if !self.tileGridNode.isHidden {
tileNodes = self.tileGridNode.tileNodes
} else {
self.fullscreenListNode.forEachItemNode { itemNode in
if let itemNode = itemNode as? VoiceChatFullscreenParticipantItemNode, let item = itemNode.item {
fullscreenItemNodes[String(item.peer.id.toInt64()) + "_" + (item.videoEndpointId ?? "")] = itemNode
}
}
self.listNode.forEachItemNode { itemNode in
if let itemNode = itemNode as? VoiceChatTilesGridItemNode {
tileNodes = itemNode.tileNodes
}
}
}
for tileNode in tileNodes {
if let item = tileNode.item {
let otherItemNode = fullscreenItemNodes[String(item.peer.id.toInt64()) + "_" + item.videoEndpointId]
tileNode.transitionIn(from: otherItemNode)
if tileNode.item?.peer.id == self.effectiveSpeaker?.0 && tileNode.item?.videoEndpointId == self.effectiveSpeaker?.1 {
tileNode.isHidden = true
}
}
}
}
private func updateDisplayMode(_ displayMode: DisplayMode, fromPan: Bool = false) {
guard !self.animatingExpansion && !self.animatingMainStage && !self.mainStageNode.animating else {
return
}
self.updateMembers()
let previousDisplayMode = self.displayMode
var isFullscreen = false
if case .fullscreen = displayMode {
isFullscreen = true
}
if case .fullscreen = previousDisplayMode, case .fullscreen = displayMode {
self.animatingExpansion = true
} else {
self.animatingMainStage = true
}
var hasFullscreenList = false
if let (layout, _) = self.validLayout, case .compact = layout.metrics.widthClass {
hasFullscreenList = true
}
let completion = {
self.displayMode = displayMode
self.updateDecorationsColors()
self.mainStageContainerNode.isHidden = false
self.mainStageContainerNode.isUserInteractionEnabled = isFullscreen
let transition: ContainedViewLayoutTransition = .animated(duration: 0.55, curve: .spring)
if case .modal = previousDisplayMode, case .fullscreen = self.displayMode {
self.mainStageNode.alpha = 0.0
self.updateDecorationsLayout(transition: .immediate)
var verticalItemNodes: [String: ASDisplayNode] = [:]
var tileNodes: [VoiceChatTileItemNode] = []
if !self.tileGridNode.isHidden {
tileNodes = self.tileGridNode.tileNodes
} else {
self.listNode.forEachItemNode { itemNode in
if let itemNode = itemNode as? VoiceChatTilesGridItemNode {
tileNodes = itemNode.tileNodes
}
}
}
for tileNode in tileNodes {
if let item = tileNode.item {
verticalItemNodes[String(item.peer.id.toInt64()) + "_" + item.videoEndpointId] = tileNode
}
}
let completion = {
let effectiveSpeakerPeerId = self.effectiveSpeaker?.0
if hasFullscreenList {
self.fullscreenListContainer.isHidden = false
self.fullscreenListNode.alpha = 0.0
}
var gridSnapshotView: UIView?
if !hasFullscreenList, let snapshotView = self.tileGridNode.view.snapshotView(afterScreenUpdates: false) {
gridSnapshotView = snapshotView
self.tileGridNode.view.addSubview(snapshotView)
self.displayPanelVideos = true
self.updateMembers(maybeUpdateVideo: false, force: true)
}
let completion = {
if hasFullscreenList {
self.attachFullscreenVideos()
self.fullscreenListNode.alpha = 1.0
self.fullscreenListNode.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.15)
}
}
if let effectiveSpeakerPeerId = effectiveSpeakerPeerId, let otherItemNode = verticalItemNodes[String(effectiveSpeakerPeerId.toInt64()) + "_" + (self.effectiveSpeaker?.1 ?? "")] {
if hasFullscreenList {
let transitionStartPosition = otherItemNode.view.convert(CGPoint(x: otherItemNode.frame.width / 2.0, y: otherItemNode.frame.height), to: self.fullscreenListContainer.view.superview)
self.fullscreenListContainer.layer.animatePosition(from: transitionStartPosition, to: self.fullscreenListContainer.position, duration: 0.55, timingFunction: kCAMediaTimingFunctionSpring)
}
self.mainStageNode.animateTransitionIn(from: otherItemNode, transition: transition, completion: { [weak self] in
self?.animatingMainStage = false
})
self.mainStageNode.alpha = 1.0
self.mainStageBackgroundNode.alpha = 1.0
self.mainStageBackgroundNode.layer.animateAlpha(from: 0.0, to: 1.0, duration: hasFullscreenList ? 0.13 : 0.3, completion: { [weak otherItemNode] _ in
otherItemNode?.alpha = 0.0
gridSnapshotView?.removeFromSuperview()
completion()
})
} else {
completion()
}
if hasFullscreenList {
self.listContainer.layer.animateScale(from: 1.0, to: 0.86, duration: 0.55, timingFunction: kCAMediaTimingFunctionSpring)
}
if self.isLandscape {
self.transitionMaskTopFillLayer.opacity = 1.0
}
self.transitionMaskBottomFillLayer.animateAlpha(from: 0.0, to: 1.0, duration: 0.3, removeOnCompletion: false, completion: { [weak self] _ in
Queue.mainQueue().after(0.3) {
self?.transitionMaskTopFillLayer.opacity = 0.0
self?.transitionMaskBottomFillLayer.removeAllAnimations()
}
})
if let (layout, navigationHeight) = self.validLayout {
self.containerLayoutUpdated(layout, navigationHeight: navigationHeight, transition: transition)
self.updateDecorationsLayout(transition: transition)
}
}
let effectiveSpeakerPeerId = self.effectiveSpeaker?.0
var index = 0
for item in self.currentFullscreenEntries {
if case let .peer(entry, _) = item, entry.peer.id == effectiveSpeakerPeerId {
break
} else {
index += 1
}
}
let position: ListViewScrollPosition
if index > self.currentFullscreenEntries.count - 3 {
index = self.currentFullscreenEntries.count - 1
position = .bottom(0.0)
} else {
position = .center(.bottom)
}
self.fullscreenListNode.transaction(deleteIndices: [], insertIndicesAndItems: [], updateIndicesAndItems: [], options: [.Synchronous, .LowLatency], scrollToItem: ListViewScrollToItem(index: index, position: position, animated: false, curve: .Default(duration: nil), directionHint: .Up), updateSizeAndInsets: nil, stationaryItemRange: nil, updateOpaqueState: nil, completion: { _ in
completion()
})
} else if case .fullscreen = previousDisplayMode, case .modal = self.displayMode {
var minimalVisiblePeerid: (PeerId, CGFloat)?
var fullscreenItemNodes: [String: VoiceChatFullscreenParticipantItemNode] = [:]
self.fullscreenListNode.forEachItemNode { itemNode in
if let itemNode = itemNode as? VoiceChatFullscreenParticipantItemNode, let item = itemNode.item {
let convertedFrame = itemNode.view.convert(itemNode.bounds, to: self.transitionContainerNode.view)
if let (_, x) = minimalVisiblePeerid {
if convertedFrame.minX >= 0.0 && convertedFrame.minX < x {
minimalVisiblePeerid = (item.peer.id, convertedFrame.minX)
}
} else if convertedFrame.minX >= 0.0 {
minimalVisiblePeerid = (item.peer.id, convertedFrame.minX)
}
fullscreenItemNodes[String(item.peer.id.toInt64()) + "_" + (item.videoEndpointId ?? "")] = itemNode
}
}
let completion = {
let effectiveSpeakerPeerId = self.effectiveSpeaker?.0
var targetTileNode: VoiceChatTileItemNode?
self.transitionContainerNode.addSubnode(self.mainStageNode)
self.listContainer.transform = CATransform3DIdentity
var tileNodes: [VoiceChatTileItemNode] = []
if !self.tileGridNode.isHidden {
tileNodes = self.tileGridNode.tileNodes
} else {
self.listNode.forEachItemNode { itemNode in
if let itemNode = itemNode as? VoiceChatTilesGridItemNode {
tileNodes = itemNode.tileNodes
}
}
}
for tileNode in tileNodes {
if let item = tileNode.item {
if item.peer.id == effectiveSpeakerPeerId, item.videoEndpointId == self.effectiveSpeaker?.1 {
targetTileNode = tileNode
}
}
}
var transitionOffset = -self.mainStageContainerNode.bounds.minY
if transitionOffset.isZero, let (layout, _) = self.validLayout {
if case .regular = layout.metrics.widthClass {
transitionOffset += 87.0
}
if let targetTileNode = targetTileNode {
let transitionTargetPosition = targetTileNode.view.convert(CGPoint(x: targetTileNode.frame.width / 2.0, y: targetTileNode.frame.height), to: self.fullscreenListContainer.view.superview)
self.fullscreenListContainer.layer.animatePosition(from: self.fullscreenListContainer.position, to: transitionTargetPosition, duration: 0.55, timingFunction: kCAMediaTimingFunctionSpring)
}
if !hasFullscreenList {
self.displayPanelVideos = false
self.listNode.forEachItemNode { itemNode in
if let itemNode = itemNode as? VoiceChatTilesGridItemNode {
itemNode.snapshotForDismissal()
}
}
self.updateMembers(maybeUpdateVideo: false, force: true)
self.attachTileVideos()
self.mainStageBackgroundNode.alpha = 0.0
self.mainStageBackgroundNode.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.25)
} else {
self.fullscreenListNode.alpha = 0.0
self.mainStageBackgroundNode.alpha = 1.0
self.fullscreenListNode.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.1, completion: { [weak self] _ in
if let strongSelf = self {
strongSelf.fullscreenListContainer.isHidden = true
strongSelf.fullscreenListNode.alpha = 1.0
strongSelf.attachTileVideos()
strongSelf.mainStageBackgroundNode.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.25)
strongSelf.mainStageBackgroundNode.alpha = 0.0
}
})
}
}
self.mainStageNode.animateTransitionOut(to: targetTileNode, offset: transitionOffset, transition: transition, completion: { [weak self] in
guard let strongSelf = self else {
return
}
strongSelf.effectiveSpeaker = nil
strongSelf.mainStageNode.update(peer: nil, waitForFullSize: false)
strongSelf.mainStageNode.setControlsHidden(false, animated: false)
strongSelf.fullscreenListContainer.isHidden = true
strongSelf.mainStageContainerNode.isHidden = true
strongSelf.mainStageContainerNode.addSubnode(strongSelf.mainStageNode)
var bounds = strongSelf.mainStageContainerNode.bounds
bounds.origin.y = 0.0
strongSelf.mainStageContainerNode.bounds = bounds
strongSelf.contentContainer.insertSubnode(strongSelf.mainStageContainerNode, belowSubnode: strongSelf.transitionContainerNode)
strongSelf.isPanning = false
strongSelf.animatingMainStage = false
})
if hasFullscreenList {
self.listContainer.layer.animateScale(from: 0.86, to: 1.0, duration: 0.55, timingFunction: kCAMediaTimingFunctionSpring)
}
self.transitionMaskTopFillLayer.animateAlpha(from: 1.0, to: 0.0, duration: 0.3)
if !transitionOffset.isZero {
self.transitionMaskBottomFillLayer.animateAlpha(from: 1.0, to: 0.0, duration: 0.3)
}
if let (layout, navigationHeight) = self.validLayout {
self.containerLayoutUpdated(layout, navigationHeight: navigationHeight, transition: transition)
self.updateDecorationsLayout(transition: transition)
}
}
if !"".isEmpty, let (peerId, _) = minimalVisiblePeerid {
var index = 0
for item in self.currentEntries {
if case let .peer(entry, _) = item, entry.peer.id == peerId {
break
} else {
index += 1
}
}
self.listNode.transaction(deleteIndices: [], insertIndicesAndItems: [], updateIndicesAndItems: [], options: [.Synchronous, .LowLatency], scrollToItem: ListViewScrollToItem(index: index, position: .top(0.0), animated: false, curve: .Default(duration: nil), directionHint: .Up), updateSizeAndInsets: nil, stationaryItemRange: nil, updateOpaqueState: nil, completion: { _ in
completion()
})
} else {
completion()
}
} else if case .fullscreen = self.displayMode {
if let (layout, navigationHeight) = self.validLayout {
let transition: ContainedViewLayoutTransition = .animated(duration: 0.4, curve: .spring)
self.containerLayoutUpdated(layout, navigationHeight: navigationHeight, transition: transition)
self.updateDecorationsLayout(transition: transition)
}
}
}
if case .fullscreen(false) = displayMode, case .modal = previousDisplayMode {
self.updateMainVideo(waitForFullSize: true, updateMembers: true, force: true, completion: {
completion()
})
} else {
completion()
}
}
fileprivate var actionButtonPosition: CGPoint {
guard let (layout, _) = self.validLayout else {
return CGPoint()
}
let size = layout.size
let hasCameraButton = self.cameraButton.isUserInteractionEnabled
let centralButtonSide = min(size.width, size.height) - 32.0
let centralButtonSize = CGSize(width: centralButtonSide, height: centralButtonSide)
if case .regular = layout.metrics.widthClass {
let contentWidth: CGFloat = max(320.0, min(375.0, floor(size.width * 0.3)))
let contentLeftInset: CGFloat
if self.peerIdToEndpointId.isEmpty {
contentLeftInset = floorToScreenPixels((layout.size.width - contentWidth) / 2.0)
} else {
contentLeftInset = self.panelHidden ? layout.size.width : layout.size.width - contentWidth
}
return CGPoint(x: contentLeftInset + floorToScreenPixels(contentWidth / 2.0), y: layout.size.height - self.effectiveBottomAreaHeight - layout.intrinsicInsets.bottom + floor(self.effectiveBottomAreaHeight / 2.0) - 3.0)
} else {
switch self.displayMode {
case .modal:
if self.isLandscape {
let sideInset: CGFloat
let buttonsCount: Int
if hasCameraButton {
sideInset = 26.0
buttonsCount = 4
} else {
sideInset = 42.0
buttonsCount = 3
}
let spacing = floor((layout.size.height - sideInset * 2.0 - sideButtonSize.height * CGFloat(buttonsCount)) / (CGFloat(buttonsCount - 1)))
let x = layout.size.width - fullscreenBottomAreaHeight - layout.safeInsets.right + floor((fullscreenBottomAreaHeight - sideButtonSize.width) / 2.0)
let actionButtonFrame = CGRect(origin: CGPoint(x: x, y: sideInset + sideButtonSize.height + spacing), size: sideButtonSize)
return actionButtonFrame.center
} else {
let actionButtonFrame = CGRect(origin: CGPoint(x: floorToScreenPixels((size.width - centralButtonSize.width) / 2.0), y: layout.size.height - self.effectiveBottomAreaHeight - layout.intrinsicInsets.bottom + floor((self.effectiveBottomAreaHeight - centralButtonSize.height) / 2.0) - 3.0), size: centralButtonSize)
return actionButtonFrame.center
}
case let .fullscreen(controlsHidden):
if self.isLandscape {
let sideInset: CGFloat
let buttonsCount: Int
if hasCameraButton {
sideInset = 26.0
buttonsCount = 4
} else {
sideInset = 42.0
buttonsCount = 3
}
let spacing = floor((layout.size.height - sideInset * 2.0 - sideButtonSize.height * CGFloat(buttonsCount)) / (CGFloat(buttonsCount - 1)))
let x = layout.size.width - fullscreenBottomAreaHeight - layout.safeInsets.right + (controlsHidden ? fullscreenBottomAreaHeight + layout.safeInsets.right + 30.0 : floor((fullscreenBottomAreaHeight - sideButtonSize.width) / 2.0))
let actionButtonFrame = CGRect(origin: CGPoint(x: x, y: sideInset + sideButtonSize.height + spacing), size: sideButtonSize)
return actionButtonFrame.center
} else {
let sideInset: CGFloat
let buttonsCount: Int
if hasCameraButton {
sideInset = 26.0
buttonsCount = 4
} else {
sideInset = 42.0
buttonsCount = 3
}
let spacing = floor((layout.size.width - sideInset * 2.0 - sideButtonSize.width * CGFloat(buttonsCount)) / (CGFloat(buttonsCount - 1)))
let y = layout.size.height - self.effectiveBottomAreaHeight - layout.intrinsicInsets.bottom + (controlsHidden ? self.effectiveBottomAreaHeight + layout.intrinsicInsets.bottom + 30.0: floor((self.effectiveBottomAreaHeight - sideButtonSize.height) / 2.0))
let secondButtonFrame: CGRect
if hasCameraButton {
let firstButtonFrame = CGRect(origin: CGPoint(x: sideInset, y: y), size: sideButtonSize)
secondButtonFrame = CGRect(origin: CGPoint(x: firstButtonFrame.maxX + spacing, y: y), size: sideButtonSize)
} else {
secondButtonFrame = CGRect(origin: CGPoint(x: sideInset, y: y), size: sideButtonSize)
}
let actionButtonFrame = CGRect(origin: CGPoint(x: secondButtonFrame.maxX + spacing, y: y), size: sideButtonSize)
return actionButtonFrame.center
}
}
}
}
}
private let sharedContext: SharedAccountContext
public let call: PresentationGroupCall
private let presentationData: PresentationData
public var parentNavigationController: NavigationController?
fileprivate let contentsReady = ValuePromise<Bool>(false, ignoreRepeated: true)
fileprivate let dataReady = ValuePromise<Bool>(false, ignoreRepeated: true)
fileprivate let audioOutputStateReady = ValuePromise<Bool>(false, ignoreRepeated: true)
private let _ready = Promise<Bool>(false)
override public var ready: Promise<Bool> {
return self._ready
}
public var onViewDidAppear: (() -> Void)?
public var onViewDidDisappear: (() -> Void)?
private var reclaimActionButton: (() -> Void)?
private var didAppearOnce: Bool = false
private var isDismissed: Bool = false
private var isDisconnected: Bool = false
private var controllerNode: Node {
return self.displayNode as! Node
}
private let idleTimerExtensionDisposable = MetaDisposable()
public weak var currentOverlayController: VoiceChatOverlayController?
private var validLayout: ContainerViewLayout?
public init(sharedContext: SharedAccountContext, accountContext: AccountContext, call: PresentationGroupCall) {
self.sharedContext = sharedContext
self.call = call
self.presentationData = sharedContext.currentPresentationData.with { $0 }
super.init(navigationBarPresentationData: nil)
self.automaticallyControlPresentationContextLayout = false
self.blocksBackgroundWhenInOverlay = true
self.supportedOrientations = ViewControllerSupportedOrientations(regularSize: .all, compactSize: .all)
self.statusBar.statusBarStyle = .Ignore
self._ready.set(combineLatest([
self.contentsReady.get(),
self.dataReady.get(),
self.audioOutputStateReady.get()
])
|> map { values -> Bool in
for value in values {
if !value {
return false
}
}
return true
}
|> filter { $0 })
self.scrollToTop = { [weak self] in
self?.controllerNode.scrollToTop()
}
}
required init(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
deinit {
self.idleTimerExtensionDisposable.dispose()
if let currentOverlayController = self.currentOverlayController {
currentOverlayController.animateOut(reclaim: false, targetPosition: CGPoint(), completion: { _ in })
}
}
override public func loadDisplayNode() {
self.displayNode = Node(controller: self, sharedContext: self.sharedContext, call: self.call)
self.displayNodeDidLoad()
}
override public func viewDidAppear(_ animated: Bool) {
super.viewDidAppear(animated)
self.isDismissed = false
if !self.didAppearOnce {
self.didAppearOnce = true
self.reclaimActionButton?()
self.controllerNode.animateIn()
self.idleTimerExtensionDisposable.set(self.sharedContext.applicationBindings.pushIdleTimerExtension())
}
DispatchQueue.main.async {
self.onViewDidAppear?()
}
}
override public func viewDidDisappear(_ animated: Bool) {
super.viewDidDisappear(animated)
self.idleTimerExtensionDisposable.set(nil)
DispatchQueue.main.async {
self.didAppearOnce = false
self.isDismissed = true
self.detachActionButton()
self.onViewDidDisappear?()
}
}
private var dismissedManually: Bool = false
public func dismiss(closing: Bool, manual: Bool = false) {
if closing {
self.isDisconnected = true
} else {
if let navigationController = self.navigationController as? NavigationController {
let count = navigationController.viewControllers.count
if count == 2 || navigationController.viewControllers[count - 2] is ChatController {
if case .active(.cantSpeak) = self.controllerNode.actionButton.stateValue {
} else if case .button = self.controllerNode.actionButton.stateValue {
} else if case .scheduled = self.controllerNode.actionButton.stateValue {
} else if let chatController = navigationController.viewControllers[count - 2] as? ChatController, chatController.isSendButtonVisible {
} else if let tabBarController = navigationController.viewControllers[count - 2] as? TabBarController, let chatListController = tabBarController.controllers[tabBarController.selectedIndex] as? ChatListController, chatListController.isSearchActive {
} else {
if manual {
self.dismissedManually = true
Queue.mainQueue().after(0.05) {
self.detachActionButton()
}
} else {
self.detachActionButton()
}
}
}
}
}
self.dismiss()
}
private func dismissAllTooltips() {
self.window?.forEachController({ controller in
if let controller = controller as? UndoOverlayController {
controller.dismissWithCommitAction()
}
})
self.forEachController({ controller in
if let controller = controller as? UndoOverlayController {
controller.dismissWithCommitAction()
}
if let controller = controller as? TooltipScreen {
controller.dismiss()
}
return true
})
}
private func detachActionButton() {
guard self.currentOverlayController == nil && !self.isDisconnected else {
return
}
let overlayController = VoiceChatOverlayController(actionButton: self.controllerNode.actionButton, audioOutputNode: self.controllerNode.audioButton, cameraNode: self.controllerNode.cameraButton, leaveNode: self.controllerNode.leaveButton, navigationController: self.navigationController as? NavigationController, initiallyHidden: self.dismissedManually)
if let navigationController = self.navigationController as? NavigationController {
navigationController.presentOverlay(controller: overlayController, inGlobal: true, blockInteraction: false)
}
self.currentOverlayController = overlayController
self.dismissedManually = false
self.reclaimActionButton = { [weak self, weak overlayController] in
if let strongSelf = self {
overlayController?.animateOut(reclaim: true, targetPosition: strongSelf.controllerNode.actionButtonPosition, completion: { immediate in
if let strongSelf = self, immediate {
strongSelf.controllerNode.actionButton.ignoreHierarchyChanges = true
strongSelf.controllerNode.bottomPanelNode.addSubnode(strongSelf.controllerNode.cameraButton)
strongSelf.controllerNode.bottomPanelNode.addSubnode(strongSelf.controllerNode.audioButton)
strongSelf.controllerNode.bottomPanelNode.addSubnode(strongSelf.controllerNode.leaveButton)
strongSelf.controllerNode.bottomPanelNode.addSubnode(strongSelf.controllerNode.actionButton)
if immediate, let layout = strongSelf.validLayout {
strongSelf.containerLayoutUpdated(layout, transition: .immediate)
}
strongSelf.controllerNode.actionButton.ignoreHierarchyChanges = false
}
})
strongSelf.reclaimActionButton = nil
}
}
}
override public func dismiss(completion: (() -> Void)? = nil) {
if !self.isDismissed {
self.isDismissed = true
self.didAppearOnce = false
self.controllerNode.animateOut(completion: { [weak self] in
completion?()
self?.dismiss(animated: false)
})
DispatchQueue.main.async {
self.onViewDidDisappear?()
}
}
}
override public func containerLayoutUpdated(_ layout: ContainerViewLayout, transition: ContainedViewLayoutTransition) {
super.containerLayoutUpdated(layout, transition: transition)
self.validLayout = layout
self.controllerNode.containerLayoutUpdated(layout, navigationHeight: self.navigationLayout(layout: layout).navigationFrame.maxY, transition: transition)
}
}
private final class VoiceChatContextExtractedContentSource: ContextExtractedContentSource {
var keepInPlace: Bool
let ignoreContentTouches: Bool = false
let blurBackground: Bool
let maskView: UIView?
private var animateTransitionIn: () -> Void
private var animateTransitionOut: () -> Void
private let sourceNode: ContextExtractedContentContainingNode
var centerVertically: Bool
var shouldBeDismissed: Signal<Bool, NoError>
init(sourceNode: ContextExtractedContentContainingNode, maskView: UIView?, keepInPlace: Bool, blurBackground: Bool, centerVertically: Bool, shouldBeDismissed: Signal<Bool, NoError>, animateTransitionIn: @escaping () -> Void, animateTransitionOut: @escaping () -> Void) {
self.sourceNode = sourceNode
self.maskView = maskView
self.keepInPlace = keepInPlace
self.blurBackground = blurBackground
self.centerVertically = centerVertically
self.shouldBeDismissed = shouldBeDismissed
self.animateTransitionIn = animateTransitionIn
self.animateTransitionOut = animateTransitionOut
}
func takeView() -> ContextControllerTakeViewInfo? {
self.animateTransitionIn()
return ContextControllerTakeViewInfo(containingItem: .node(self.sourceNode), contentAreaInScreenSpace: UIScreen.main.bounds, maskView: self.maskView)
}
func putBack() -> ContextControllerPutBackViewInfo? {
self.animateTransitionOut()
return ContextControllerPutBackViewInfo(contentAreaInScreenSpace: UIScreen.main.bounds, maskView: self.maskView)
}
}
private final class VoiceChatContextReferenceContentSource: ContextReferenceContentSource {
private let controller: ViewController
private let sourceNode: ContextReferenceContentNode
init(controller: ViewController, sourceNode: ContextReferenceContentNode) {
self.controller = controller
self.sourceNode = sourceNode
}
func transitionInfo() -> ContextControllerReferenceViewInfo? {
return ContextControllerReferenceViewInfo(referenceView: self.sourceNode.view, contentAreaInScreenSpace: UIScreen.main.bounds)
}
}