mirror of
https://github.com/Swiftgram/Telegram-iOS.git
synced 2025-06-16 05:55:20 +00:00
462 lines
24 KiB
Swift
462 lines
24 KiB
Swift
import Foundation
|
|
import AsyncDisplayKit
|
|
import Display
|
|
import Postbox
|
|
import TelegramCore
|
|
import SwiftSignalKit
|
|
import LegacyComponents
|
|
|
|
enum ChatTitleContent {
|
|
case peer(PeerView)
|
|
case group([Peer])
|
|
}
|
|
|
|
private final class ChatTitleNetworkStatusNode: ASDisplayNode {
|
|
private var theme: PresentationTheme
|
|
|
|
private let titleNode: ASTextNode
|
|
private let activityIndicator: ActivityIndicator
|
|
|
|
var title: String = "" {
|
|
didSet {
|
|
if self.title != oldValue {
|
|
self.titleNode.attributedText = NSAttributedString(string: title, font: Font.bold(17.0), textColor: self.theme.rootController.navigationBar.primaryTextColor)
|
|
}
|
|
}
|
|
}
|
|
|
|
init(theme: PresentationTheme) {
|
|
self.theme = theme
|
|
|
|
self.titleNode = ASTextNode()
|
|
self.titleNode.isLayerBacked = true
|
|
self.titleNode.displaysAsynchronously = false
|
|
self.titleNode.maximumNumberOfLines = 1
|
|
self.titleNode.truncationMode = .byTruncatingTail
|
|
self.titleNode.isOpaque = false
|
|
self.titleNode.isUserInteractionEnabled = false
|
|
|
|
self.activityIndicator = ActivityIndicator(type: .custom(theme.rootController.navigationBar.primaryTextColor, 22.0, 1.5), speed: .slow)
|
|
let activityIndicatorSize = self.activityIndicator.measure(CGSize(width: 100.0, height: 100.0))
|
|
self.activityIndicator.frame = CGRect(origin: CGPoint(), size: activityIndicatorSize)
|
|
|
|
super.init()
|
|
|
|
self.addSubnode(self.titleNode)
|
|
self.addSubnode(self.activityIndicator)
|
|
}
|
|
|
|
func updateLayout(size: CGSize, transition: ContainedViewLayoutTransition) {
|
|
let indicatorSize = self.activityIndicator.bounds.size
|
|
let indicatorPadding = indicatorSize.width + 6.0
|
|
|
|
let titleSize = self.titleNode.measure(CGSize(width: max(1.0, size.width - indicatorPadding), height: size.height))
|
|
let combinedHeight = titleSize.height
|
|
|
|
let titleFrame = CGRect(origin: CGPoint(x: indicatorPadding + floor((size.width - titleSize.width - indicatorPadding) / 2.0), y: floor((size.height - combinedHeight) / 2.0)), size: titleSize)
|
|
transition.updateFrame(node: self.titleNode, frame: titleFrame)
|
|
|
|
transition.updateFrame(node: self.activityIndicator, frame: CGRect(origin: CGPoint(x: titleFrame.minX - indicatorSize.width - 6.0, y: titleFrame.minY - 1.0), size: indicatorSize))
|
|
}
|
|
}
|
|
|
|
final class ChatTitleView: UIView, NavigationBarTitleView {
|
|
private let account: Account
|
|
|
|
private var theme: PresentationTheme
|
|
private var strings: PresentationStrings
|
|
private var timeFormat: PresentationTimeFormat
|
|
|
|
private let contentContainer: ASDisplayNode
|
|
private let titleNode: ASTextNode
|
|
private let infoNode: ASTextNode
|
|
private let typingNode: ASTextNode
|
|
private var typingIndicator: TGModernConversationTitleActivityIndicator?
|
|
private let button: HighlightTrackingButtonNode
|
|
|
|
private var networkStatusNode: ChatTitleNetworkStatusNode?
|
|
|
|
private var presenceManager: PeerPresenceStatusManager?
|
|
|
|
var inputActivities: (PeerId, [(Peer, PeerInputActivity)])? {
|
|
didSet {
|
|
if let (peerId, inputActivities) = self.inputActivities, !inputActivities.isEmpty {
|
|
self.typingNode.isHidden = false
|
|
self.infoNode.isHidden = true
|
|
var stringValue = ""
|
|
var first = true
|
|
var mergedActivity = inputActivities[0].1
|
|
for (_, activity) in inputActivities {
|
|
if activity != mergedActivity {
|
|
mergedActivity = .typingText
|
|
break
|
|
}
|
|
}
|
|
if peerId.namespace == Namespaces.Peer.CloudUser || peerId.namespace == Namespaces.Peer.SecretChat {
|
|
switch mergedActivity {
|
|
case .typingText:
|
|
stringValue = strings.Conversation_typing
|
|
case .uploadingFile:
|
|
stringValue = strings.Activity_UploadingDocument
|
|
case .recordingVoice:
|
|
stringValue = strings.Activity_RecordingAudio
|
|
case .uploadingPhoto:
|
|
stringValue = strings.Activity_UploadingPhoto
|
|
case .uploadingVideo:
|
|
stringValue = strings.Activity_UploadingVideo
|
|
case .playingGame:
|
|
stringValue = strings.Activity_PlayingGame
|
|
case .recordingInstantVideo:
|
|
stringValue = strings.Activity_RecordingVideoMessage
|
|
case .uploadingInstantVideo:
|
|
stringValue = strings.Activity_UploadingVideoMessage
|
|
}
|
|
} else {
|
|
for (peer, _) in inputActivities {
|
|
let title = peer.compactDisplayTitle
|
|
if !title.isEmpty {
|
|
if first {
|
|
first = false
|
|
} else {
|
|
stringValue += ", "
|
|
}
|
|
stringValue += title
|
|
}
|
|
}
|
|
}
|
|
let string = NSAttributedString(string: stringValue, font: Font.regular(13.0), textColor: self.theme.rootController.navigationBar.accentTextColor)
|
|
if self.typingNode.attributedText == nil || !self.typingNode.attributedText!.isEqual(to: string) {
|
|
self.typingNode.attributedText = string
|
|
self.setNeedsLayout()
|
|
}
|
|
if self.typingIndicator == nil {
|
|
let typingIndicator = TGModernConversationTitleActivityIndicator()
|
|
typingIndicator.setColor(self.theme.rootController.navigationBar.accentTextColor)
|
|
self.contentContainer.view.addSubview(typingIndicator)
|
|
self.typingIndicator = typingIndicator
|
|
}
|
|
switch mergedActivity {
|
|
case .typingText:
|
|
self.typingIndicator?.setTyping()
|
|
case .recordingVoice:
|
|
self.typingIndicator?.setAudioRecording()
|
|
case .uploadingFile:
|
|
self.typingIndicator?.setUploading()
|
|
case .playingGame:
|
|
self.typingIndicator?.setPlaying()
|
|
case .recordingInstantVideo:
|
|
self.typingIndicator?.setAudioRecording()
|
|
case .uploadingInstantVideo:
|
|
self.typingIndicator?.setUploading()
|
|
case .uploadingPhoto:
|
|
self.typingIndicator?.setUploading()
|
|
case .uploadingVideo:
|
|
self.typingIndicator?.setUploading()
|
|
}
|
|
} else {
|
|
self.typingNode.isHidden = true
|
|
self.infoNode.isHidden = false
|
|
self.typingNode.attributedText = nil
|
|
if let typingIndicator = self.typingIndicator {
|
|
typingIndicator.removeFromSuperview()
|
|
self.typingIndicator = nil
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
var networkState: AccountNetworkState = .online {
|
|
didSet {
|
|
if self.networkState != oldValue {
|
|
if case .online = self.networkState {
|
|
self.contentContainer.isHidden = false
|
|
if let networkStatusNode = self.networkStatusNode {
|
|
self.networkStatusNode = nil
|
|
networkStatusNode.removeFromSupernode()
|
|
}
|
|
} else {
|
|
self.contentContainer.isHidden = true
|
|
let statusNode: ChatTitleNetworkStatusNode
|
|
if let current = self.networkStatusNode {
|
|
statusNode = current
|
|
} else {
|
|
statusNode = ChatTitleNetworkStatusNode(theme: self.theme)
|
|
self.networkStatusNode = statusNode
|
|
self.insertSubview(statusNode.view, belowSubview: self.button.view)
|
|
}
|
|
switch self.networkState {
|
|
case .waitingForNetwork:
|
|
statusNode.title = self.strings.State_WaitingForNetwork
|
|
case let .connecting(toProxy):
|
|
statusNode.title = toProxy ? self.strings.State_ConnectingToProxy : self.strings.State_Connecting
|
|
case .updating:
|
|
statusNode.title = self.strings.State_Updating
|
|
case .online:
|
|
break
|
|
}
|
|
|
|
}
|
|
|
|
self.setNeedsLayout()
|
|
}
|
|
}
|
|
}
|
|
|
|
var pressed: (() -> Void)?
|
|
|
|
var titleContent: ChatTitleContent? {
|
|
didSet {
|
|
if let titleContent = self.titleContent {
|
|
var string: NSAttributedString?
|
|
switch titleContent {
|
|
case let .peer(peerView):
|
|
if let peer = peerViewMainPeer(peerView) {
|
|
if peerView.peerId == self.account.peerId {
|
|
string = NSAttributedString(string: self.strings.Conversation_SavedMessages, font: Font.medium(17.0), textColor: self.theme.rootController.navigationBar.primaryTextColor)
|
|
} else {
|
|
string = NSAttributedString(string: peer.displayTitle, font: Font.medium(17.0), textColor: self.theme.rootController.navigationBar.primaryTextColor)
|
|
}
|
|
}
|
|
case .group:
|
|
string = NSAttributedString(string: "Feed", font: Font.medium(17.0), textColor: self.theme.rootController.navigationBar.primaryTextColor)
|
|
}
|
|
|
|
if let string = string, self.titleNode.attributedText == nil || !self.titleNode.attributedText!.isEqual(to: string) {
|
|
self.titleNode.attributedText = string
|
|
self.setNeedsLayout()
|
|
}
|
|
|
|
self.updateStatus()
|
|
}
|
|
}
|
|
}
|
|
|
|
private func updateStatus() {
|
|
var shouldUpdateLayout = false
|
|
if let titleContent = self.titleContent {
|
|
switch titleContent {
|
|
case let .peer(peerView):
|
|
if let peer = peerViewMainPeer(peerView) {
|
|
if peer.id == self.account.peerId {
|
|
let string = NSAttributedString(string: "", font: Font.regular(13.0), textColor: self.theme.rootController.navigationBar.secondaryTextColor)
|
|
if self.infoNode.attributedText == nil || !self.infoNode.attributedText!.isEqual(to: string) {
|
|
self.infoNode.attributedText = string
|
|
shouldUpdateLayout = true
|
|
}
|
|
} else if let user = peer as? TelegramUser {
|
|
if let _ = user.botInfo {
|
|
let string = NSAttributedString(string: self.strings.Bot_GenericBotStatus, font: Font.regular(13.0), textColor: self.theme.rootController.navigationBar.secondaryTextColor)
|
|
if self.infoNode.attributedText == nil || !self.infoNode.attributedText!.isEqual(to: string) {
|
|
self.infoNode.attributedText = string
|
|
shouldUpdateLayout = true
|
|
}
|
|
} else if let peer = peerViewMainPeer(peerView), let presence = peerView.peerPresences[peer.id] as? TelegramUserPresence {
|
|
let timestamp = CFAbsoluteTimeGetCurrent() + NSTimeIntervalSince1970
|
|
let (string, activity) = stringAndActivityForUserPresence(strings: self.strings, timeFormat: self.timeFormat, presence: presence, relativeTo: Int32(timestamp))
|
|
let attributedString = NSAttributedString(string: string, font: Font.regular(13.0), textColor: activity ? self.theme.rootController.navigationBar.accentTextColor : self.theme.rootController.navigationBar.secondaryTextColor)
|
|
if self.infoNode.attributedText == nil || !self.infoNode.attributedText!.isEqual(to: attributedString) {
|
|
self.infoNode.attributedText = attributedString
|
|
shouldUpdateLayout = true
|
|
}
|
|
|
|
self.presenceManager?.reset(presence: presence)
|
|
} else {
|
|
let string = NSAttributedString(string: strings.LastSeen_ALongTimeAgo, font: Font.regular(13.0), textColor: self.theme.rootController.navigationBar.secondaryTextColor)
|
|
if self.infoNode.attributedText == nil || !self.infoNode.attributedText!.isEqual(to: string) {
|
|
self.infoNode.attributedText = string
|
|
shouldUpdateLayout = true
|
|
}
|
|
}
|
|
} else if let group = peer as? TelegramGroup {
|
|
var onlineCount = 0
|
|
if let cachedGroupData = peerView.cachedData as? CachedGroupData, let participants = cachedGroupData.participants {
|
|
let timestamp = CFAbsoluteTimeGetCurrent() + NSTimeIntervalSince1970
|
|
for participant in participants.participants {
|
|
if let presence = peerView.peerPresences[participant.peerId] as? TelegramUserPresence {
|
|
let relativeStatus = relativeUserPresenceStatus(presence, relativeTo: Int32(timestamp))
|
|
switch relativeStatus {
|
|
case .online:
|
|
onlineCount += 1
|
|
default:
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if onlineCount > 1 {
|
|
let string = NSMutableAttributedString()
|
|
|
|
string.append(NSAttributedString(string: "\(strings.Conversation_StatusMembers(Int32(group.participantCount))), ", font: Font.regular(13.0), textColor: self.theme.rootController.navigationBar.secondaryTextColor))
|
|
string.append(NSAttributedString(string: strings.Conversation_StatusOnline(Int32(onlineCount)), font: Font.regular(13.0), textColor: self.theme.rootController.navigationBar.secondaryTextColor))
|
|
if self.infoNode.attributedText == nil || !self.infoNode.attributedText!.isEqual(to: string) {
|
|
self.infoNode.attributedText = string
|
|
shouldUpdateLayout = true
|
|
}
|
|
} else {
|
|
let string = NSAttributedString(string: strings.Conversation_StatusMembers(Int32(group.participantCount)), font: Font.regular(13.0), textColor: self.theme.rootController.navigationBar.secondaryTextColor)
|
|
if self.infoNode.attributedText == nil || !self.infoNode.attributedText!.isEqual(to: string) {
|
|
self.infoNode.attributedText = string
|
|
shouldUpdateLayout = true
|
|
}
|
|
}
|
|
} else if let channel = peer as? TelegramChannel {
|
|
if let cachedChannelData = peerView.cachedData as? CachedChannelData, let memberCount = cachedChannelData.participantsSummary.memberCount {
|
|
let string = NSAttributedString(string: strings.Conversation_StatusMembers(memberCount), font: Font.regular(13.0), textColor: self.theme.rootController.navigationBar.secondaryTextColor)
|
|
if self.infoNode.attributedText == nil || !self.infoNode.attributedText!.isEqual(to: string) {
|
|
self.infoNode.attributedText = string
|
|
shouldUpdateLayout = true
|
|
}
|
|
} else {
|
|
switch channel.info {
|
|
case .group:
|
|
let string = NSAttributedString(string: strings.Group_Status, font: Font.regular(13.0), textColor: self.theme.rootController.navigationBar.secondaryTextColor)
|
|
if self.infoNode.attributedText == nil || !self.infoNode.attributedText!.isEqual(to: string) {
|
|
self.infoNode.attributedText = string
|
|
shouldUpdateLayout = true
|
|
}
|
|
case .broadcast:
|
|
let string = NSAttributedString(string: strings.Channel_Status, font: Font.regular(13.0), textColor: self.theme.rootController.navigationBar.secondaryTextColor)
|
|
if self.infoNode.attributedText == nil || !self.infoNode.attributedText!.isEqual(to: string) {
|
|
self.infoNode.attributedText = string
|
|
shouldUpdateLayout = true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
case .group:
|
|
break
|
|
}
|
|
|
|
if shouldUpdateLayout {
|
|
self.setNeedsLayout()
|
|
}
|
|
}
|
|
}
|
|
|
|
init(account: Account, theme: PresentationTheme, strings: PresentationStrings, timeFormat: PresentationTimeFormat) {
|
|
self.account = account
|
|
self.theme = theme
|
|
self.strings = strings
|
|
self.timeFormat = timeFormat
|
|
|
|
self.contentContainer = ASDisplayNode()
|
|
|
|
self.titleNode = ASTextNode()
|
|
self.titleNode.displaysAsynchronously = false
|
|
self.titleNode.maximumNumberOfLines = 1
|
|
self.titleNode.truncationMode = .byTruncatingTail
|
|
self.titleNode.isOpaque = false
|
|
|
|
self.infoNode = ASTextNode()
|
|
self.infoNode.displaysAsynchronously = false
|
|
self.infoNode.maximumNumberOfLines = 1
|
|
self.infoNode.truncationMode = .byTruncatingTail
|
|
self.infoNode.isOpaque = false
|
|
|
|
self.typingNode = ASTextNode()
|
|
self.typingNode.displaysAsynchronously = false
|
|
self.typingNode.maximumNumberOfLines = 1
|
|
self.typingNode.truncationMode = .byTruncatingTail
|
|
self.typingNode.isOpaque = false
|
|
|
|
self.button = HighlightTrackingButtonNode()
|
|
|
|
super.init(frame: CGRect())
|
|
|
|
self.addSubnode(self.contentContainer)
|
|
self.contentContainer.addSubnode(self.titleNode)
|
|
self.contentContainer.addSubnode(self.infoNode)
|
|
self.contentContainer.addSubnode(self.typingNode)
|
|
self.addSubnode(self.button)
|
|
|
|
self.presenceManager = PeerPresenceStatusManager(update: { [weak self] in
|
|
self?.updateStatus()
|
|
})
|
|
|
|
self.button.addTarget(self, action: #selector(buttonPressed), forControlEvents: [.touchUpInside])
|
|
self.button.highligthedChanged = { [weak self] highlighted in
|
|
if let strongSelf = self {
|
|
if highlighted {
|
|
strongSelf.titleNode.layer.removeAnimation(forKey: "opacity")
|
|
strongSelf.infoNode.layer.removeAnimation(forKey: "opacity")
|
|
strongSelf.typingNode.layer.removeAnimation(forKey: "opacity")
|
|
strongSelf.titleNode.alpha = 0.4
|
|
strongSelf.infoNode.alpha = 0.4
|
|
strongSelf.typingNode.alpha = 0.4
|
|
} else {
|
|
strongSelf.titleNode.alpha = 1.0
|
|
strongSelf.infoNode.alpha = 1.0
|
|
strongSelf.typingNode.alpha = 1.0
|
|
strongSelf.titleNode.layer.animateAlpha(from: 0.4, to: 1.0, duration: 0.2)
|
|
strongSelf.infoNode.layer.animateAlpha(from: 0.4, to: 1.0, duration: 0.2)
|
|
strongSelf.typingNode.layer.animateAlpha(from: 0.4, to: 1.0, duration: 0.2)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
required init?(coder aDecoder: NSCoder) {
|
|
fatalError("init(coder:) has not been implemented")
|
|
}
|
|
|
|
override func layoutSubviews() {
|
|
super.layoutSubviews()
|
|
|
|
let size = self.bounds.size
|
|
let transition: ContainedViewLayoutTransition = .immediate
|
|
|
|
self.button.frame = CGRect(origin: CGPoint(), size: size)
|
|
self.contentContainer.frame = CGRect(origin: CGPoint(), size: size)
|
|
|
|
if size.height > 40.0 {
|
|
let titleSize = self.titleNode.measure(size)
|
|
let infoSize = self.infoNode.measure(size)
|
|
let typingSize = self.typingNode.measure(size)
|
|
let titleInfoSpacing: CGFloat = 0.0
|
|
|
|
if infoSize.width.isZero && typingSize.width.isZero {
|
|
self.titleNode.frame = CGRect(origin: CGPoint(x: floor((size.width - titleSize.width) / 2.0), y: floor((size.height - titleSize.height) / 2.0)), size: titleSize)
|
|
} else {
|
|
let combinedHeight = titleSize.height + infoSize.height + titleInfoSpacing
|
|
|
|
self.titleNode.frame = CGRect(origin: CGPoint(x: floor((size.width - titleSize.width) / 2.0), y: floor((size.height - combinedHeight) / 2.0)), size: titleSize)
|
|
self.infoNode.frame = CGRect(origin: CGPoint(x: floor((size.width - infoSize.width) / 2.0), y: floor((size.height - combinedHeight) / 2.0) + titleSize.height + titleInfoSpacing), size: infoSize)
|
|
self.typingNode.frame = CGRect(origin: CGPoint(x: floor((size.width - typingSize.width + 14.0) / 2.0), y: floor((size.height - combinedHeight) / 2.0) + titleSize.height + titleInfoSpacing), size: typingSize)
|
|
|
|
if let typingIndicator = self.typingIndicator {
|
|
typingIndicator.frame = CGRect(x: self.typingNode.frame.origin.x - 24.0, y: self.typingNode.frame.origin.y, width: 24.0, height: 16.0)
|
|
}
|
|
}
|
|
} else {
|
|
let titleSize = self.titleNode.measure(CGSize(width: floor(size.width / 2.0), height: size.height))
|
|
let infoSize = self.infoNode.measure(CGSize(width: floor(size.width / 2.0), height: size.height))
|
|
let typingSize = self.typingNode.measure(CGSize(width: floor(size.width / 2.0), height: size.height))
|
|
|
|
let titleInfoSpacing: CGFloat = 8.0
|
|
let combinedWidth = titleSize.width + infoSize.width + titleInfoSpacing
|
|
|
|
self.titleNode.frame = CGRect(origin: CGPoint(x: floor((size.width - combinedWidth) / 2.0), y: floor((size.height - titleSize.height) / 2.0)), size: titleSize)
|
|
self.infoNode.frame = CGRect(origin: CGPoint(x: floor((size.width - combinedWidth) / 2.0 + titleSize.width + titleInfoSpacing), y: floor((size.height - infoSize.height) / 2.0)), size: infoSize)
|
|
self.typingNode.frame = CGRect(origin: CGPoint(x: floor((size.width - combinedWidth) / 2.0 + titleSize.width + titleInfoSpacing), y: floor((size.height - typingSize.height) / 2.0)), size: typingSize)
|
|
}
|
|
|
|
if let networkStatusNode = self.networkStatusNode {
|
|
transition.updateFrame(node: networkStatusNode, frame: CGRect(origin: CGPoint(), size: size))
|
|
networkStatusNode.updateLayout(size: size, transition: transition)
|
|
}
|
|
}
|
|
|
|
@objc func buttonPressed() {
|
|
if let pressed = self.pressed {
|
|
pressed()
|
|
}
|
|
}
|
|
|
|
func animateLayoutTransition() {
|
|
UIView.transition(with: self, duration: 0.25, options: [.transitionCrossDissolve], animations: {
|
|
|
|
}, completion: nil)
|
|
}
|
|
}
|