434 lines
17 KiB
Swift
434 lines
17 KiB
Swift
//
|
|
// StatusTableViewCell.swift
|
|
// Tusker
|
|
//
|
|
// Created by Shadowfacts on 8/16/18.
|
|
// Copyright © 2018 Shadowfacts. All rights reserved.
|
|
//
|
|
|
|
import UIKit
|
|
import Combine
|
|
import Pachyderm
|
|
|
|
protocol StatusTableViewCellDelegate: TuskerNavigationDelegate {
|
|
func statusCollapsedStateChanged()
|
|
}
|
|
|
|
class StatusTableViewCell: UITableViewCell {
|
|
|
|
var delegate: StatusTableViewCellDelegate? {
|
|
didSet {
|
|
contentLabel.navigationDelegate = delegate
|
|
}
|
|
}
|
|
|
|
@IBOutlet weak var displayNameLabel: UILabel!
|
|
@IBOutlet weak var usernameLabel: UILabel!
|
|
@IBOutlet weak var contentWarningLabel: UILabel!
|
|
@IBOutlet weak var collapseButton: UIButton!
|
|
@IBOutlet weak var contentLabel: StatusContentLabel!
|
|
@IBOutlet weak var avatarImageView: UIImageView!
|
|
@IBOutlet weak var reblogLabel: UILabel!
|
|
@IBOutlet weak var timestampLabel: UILabel!
|
|
@IBOutlet weak var attachmentsView: AttachmentsContainerView!
|
|
@IBOutlet weak var favoriteButton: UIButton!
|
|
@IBOutlet weak var reblogButton: UIButton!
|
|
|
|
var statusID: String!
|
|
var accountID: String!
|
|
var reblogStatusID: String?
|
|
var rebloggerID: String?
|
|
|
|
var favorited: Bool = false {
|
|
didSet {
|
|
favoriteButton.tintColor = favorited ? UIColor(displayP3Red: 1, green: 0.8, blue: 0, alpha: 1) : tintColor
|
|
}
|
|
}
|
|
var reblogged: Bool = false {
|
|
didSet {
|
|
reblogButton.tintColor = reblogged ? UIColor(displayP3Red: 1, green: 0.8, blue: 0, alpha: 1) : tintColor
|
|
}
|
|
}
|
|
|
|
var collapsible = false {
|
|
didSet {
|
|
collapseButton.isHidden = !collapsible
|
|
}
|
|
}
|
|
var collapsed = false
|
|
|
|
var avatarURL: URL?
|
|
var updateTimestampWorkItem: DispatchWorkItem?
|
|
var attachmentDataTasks: [URLSessionDataTask] = []
|
|
|
|
var statusUpdater: Cancellable?
|
|
var accountUpdater: Cancellable?
|
|
var rebloggerAccountUpdater: Cancellable?
|
|
|
|
deinit {
|
|
statusUpdater?.cancel()
|
|
accountUpdater?.cancel()
|
|
rebloggerAccountUpdater?.cancel()
|
|
}
|
|
|
|
override func awakeFromNib() {
|
|
displayNameLabel.addGestureRecognizer(UITapGestureRecognizer(target: self, action: #selector(accountPressed)))
|
|
usernameLabel.addGestureRecognizer(UITapGestureRecognizer(target: self, action: #selector(accountPressed)))
|
|
reblogLabel.addGestureRecognizer(UITapGestureRecognizer(target: self, action: #selector(reblogLabelPressed)))
|
|
avatarImageView.addGestureRecognizer(UITapGestureRecognizer(target: self, action: #selector(accountPressed)))
|
|
avatarImageView.layer.masksToBounds = true
|
|
attachmentsView.delegate = self
|
|
attachmentsView.layer.cornerRadius = 5
|
|
attachmentsView.layer.masksToBounds = true
|
|
collapseButton.layer.masksToBounds = true
|
|
collapseButton.layer.cornerRadius = 5
|
|
|
|
NotificationCenter.default.addObserver(self, selector: #selector(updateUIForPreferences), name: .preferencesChanged, object: nil)
|
|
|
|
statusUpdater = MastodonCache.statusSubject
|
|
.filter { $0.id == self.statusID }
|
|
.receive(on: DispatchQueue.main)
|
|
.sink(receiveValue: updateStatusState(status:))
|
|
|
|
accountUpdater = MastodonCache.accountSubject
|
|
.filter { $0.id == self.accountID }
|
|
.receive(on: DispatchQueue.main)
|
|
.sink(receiveValue: updateUI(account:))
|
|
|
|
rebloggerAccountUpdater = MastodonCache.accountSubject
|
|
.filter { $0.id == self.rebloggerID }
|
|
.receive(on: DispatchQueue.main)
|
|
.sink(receiveValue: { (_) in
|
|
// this method is responsible for setting the reblog label text
|
|
self.updateUIForPreferences()
|
|
})
|
|
}
|
|
|
|
func updateUI(statusID: String) {
|
|
guard var status = MastodonCache.status(for: statusID) else { fatalError("Missing cached status \(statusID)") }
|
|
self.statusID = statusID
|
|
|
|
if let rebloggedStatusID = status.reblog?.id,
|
|
let rebloggedStatus = MastodonCache.status(for: rebloggedStatusID) {
|
|
reblogStatusID = statusID
|
|
rebloggerID = status.account.id
|
|
status = rebloggedStatus
|
|
self.statusID = rebloggedStatus.id
|
|
reblogLabel.isHidden = false
|
|
} else {
|
|
reblogStatusID = nil
|
|
rebloggerID = nil
|
|
reblogLabel.isHidden = true
|
|
}
|
|
let account = status.account
|
|
self.accountID = account.id
|
|
updateUI(account: account)
|
|
|
|
updateUIForPreferences()
|
|
|
|
updateTimestamp()
|
|
|
|
attachmentsView.updateUI(status: status)
|
|
|
|
let realStatus = status.reblog ?? status
|
|
updateStatusState(status: realStatus)
|
|
|
|
contentLabel.statusID = status.id
|
|
|
|
collapsible = !status.spoilerText.isEmpty
|
|
setCollapsed(collapsible, animated: false)
|
|
contentWarningLabel.text = status.spoilerText
|
|
contentWarningLabel.isHidden = status.spoilerText.isEmpty
|
|
}
|
|
|
|
private func updateStatusState(status: Status) {
|
|
favorited = status.favourited ?? false
|
|
reblogged = status.reblogged ?? false
|
|
}
|
|
|
|
private func updateUI(account: Account) {
|
|
usernameLabel.text = "@\(account.acct)"
|
|
avatarImageView.image = nil
|
|
avatarURL = account.avatar
|
|
ImageCache.avatars.get(account.avatar) { (data) in
|
|
guard let data = data else { return }
|
|
DispatchQueue.main.async {
|
|
self.avatarImageView.image = UIImage(data: data)
|
|
self.avatarURL = nil
|
|
}
|
|
}
|
|
}
|
|
|
|
@objc func updateUIForPreferences() {
|
|
guard let account = MastodonCache.account(for: accountID) else { fatalError("") }
|
|
avatarImageView.layer.cornerRadius = Preferences.shared.avatarStyle.cornerRadius(for: avatarImageView)
|
|
if let rebloggerID = rebloggerID,
|
|
let reblogger = MastodonCache.account(for: rebloggerID) {
|
|
reblogLabel.text = "Reblogged by \(reblogger.realDisplayName)"
|
|
}
|
|
displayNameLabel.text = account.realDisplayName
|
|
}
|
|
|
|
func updateTimestamp() {
|
|
guard let status = MastodonCache.status(for: statusID) else { fatalError("Missing cached status \(statusID!)") }
|
|
|
|
timestampLabel.text = status.createdAt.timeAgoString()
|
|
let delay: DispatchTimeInterval?
|
|
switch status.createdAt.timeAgo().1 {
|
|
case .second:
|
|
delay = .seconds(10)
|
|
case .minute:
|
|
delay = .seconds(60)
|
|
default:
|
|
delay = nil
|
|
}
|
|
if let delay = delay {
|
|
updateTimestampWorkItem = DispatchWorkItem {
|
|
self.updateTimestamp()
|
|
}
|
|
DispatchQueue.main.asyncAfter(deadline: .now() + delay, execute: updateTimestampWorkItem!)
|
|
} else {
|
|
updateTimestampWorkItem = nil
|
|
}
|
|
}
|
|
|
|
override func prepareForReuse() {
|
|
if let url = avatarURL {
|
|
ImageCache.avatars.cancel(url)
|
|
}
|
|
updateTimestampWorkItem?.cancel()
|
|
updateTimestampWorkItem = nil
|
|
attachmentsView.subviews.forEach { $0.removeFromSuperview() }
|
|
}
|
|
|
|
override func setSelected(_ selected: Bool, animated: Bool) {
|
|
super.setSelected(selected, animated: animated)
|
|
|
|
if selected {
|
|
delegate?.selected(status: statusID)
|
|
}
|
|
}
|
|
|
|
@IBAction func collapseButtonPressed(_ sender: Any) {
|
|
setCollapsed(!collapsed, animated: true)
|
|
delegate?.statusCollapsedStateChanged()
|
|
}
|
|
|
|
func setCollapsed(_ collapsed: Bool, animated: Bool) {
|
|
self.collapsed = collapsed
|
|
|
|
contentLabel.isHidden = collapsed
|
|
attachmentsView.isHidden = attachmentsView.attachments.count == 0 || collapsed
|
|
|
|
let buttonImage = UIImage(systemName: collapsed ? "chevron.down" : "chevron.up")
|
|
|
|
if animated, let buttonImageView = collapseButton.imageView {
|
|
// we need to use a keyframe animation for this, because we want to control the direction the chevron rotates
|
|
// when rotating ±π, UIKit will always rotate in the same direction
|
|
// using a keyframe to set an intermediate point in the animation allows us to force a specific direction
|
|
UIView.animateKeyframes(withDuration: 0.2, delay: 0, options: .calculationModeLinear, animations: {
|
|
UIView.addKeyframe(withRelativeStartTime: 0, relativeDuration: 0.5) {
|
|
buttonImageView.transform = CGAffineTransform(rotationAngle: collapsed ? .pi / 2 : -.pi / 2)
|
|
}
|
|
UIView.addKeyframe(withRelativeStartTime: 0.5, relativeDuration: 0.5) {
|
|
buttonImageView.transform = CGAffineTransform(rotationAngle: .pi)
|
|
}
|
|
}, completion: { (finished) in
|
|
buttonImageView.transform = .identity
|
|
self.collapseButton.setImage(buttonImage, for: .normal)
|
|
})
|
|
} else {
|
|
collapseButton.setImage(buttonImage, for: .normal)
|
|
}
|
|
}
|
|
|
|
@IBAction func replyPressed(_ sender: Any) {
|
|
delegate?.reply(to: statusID)
|
|
}
|
|
|
|
@objc func accountPressed() {
|
|
delegate?.selected(account: accountID)
|
|
}
|
|
|
|
@objc func reblogLabelPressed() {
|
|
guard let rebloggerID = rebloggerID else { return }
|
|
delegate?.selected(account: rebloggerID)
|
|
}
|
|
|
|
@IBAction func favoritePressed(_ sender: Any) {
|
|
guard let status = MastodonCache.status(for: statusID) else { fatalError("Missing cached status \(statusID!)") }
|
|
|
|
let oldValue = favorited
|
|
favorited = !favorited
|
|
|
|
let realStatus: Status = status.reblog ?? status
|
|
let request = (favorited ? Status.favourite : Status.unfavourite)(realStatus)
|
|
MastodonController.client.run(request) { response in
|
|
DispatchQueue.main.async {
|
|
if case let .success(newStatus, _) = response {
|
|
self.favorited = newStatus.favourited ?? false
|
|
MastodonCache.add(status: newStatus)
|
|
UIImpactFeedbackGenerator(style: .light).impactOccurred()
|
|
} else {
|
|
self.favorited = oldValue
|
|
print("Couldn't favorite status \(realStatus.id)")
|
|
// todo: display error message
|
|
UINotificationFeedbackGenerator().notificationOccurred(.error)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@IBAction func reblogPressed(_ sender: Any) {
|
|
guard let status = MastodonCache.status(for: statusID) else { fatalError("Missing cached status \(statusID!)") }
|
|
|
|
let oldValue = reblogged
|
|
reblogged = !reblogged
|
|
|
|
let realStatus: Status = status.reblog ?? status
|
|
let request = (reblogged ? Status.reblog : Status.unreblog)(realStatus)
|
|
MastodonController.client.run(request) { response in
|
|
DispatchQueue.main.async {
|
|
if case let .success(newStatus, _) = response {
|
|
self.reblogged = newStatus.reblogged ?? false
|
|
MastodonCache.add(status: newStatus)
|
|
UIImpactFeedbackGenerator(style: .light).impactOccurred()
|
|
} else {
|
|
self.reblogged = oldValue
|
|
print("Couldn't reblog status \(realStatus.id)")
|
|
// todo: display error message
|
|
UINotificationFeedbackGenerator().notificationOccurred(.error)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@IBAction func morePressed(_ sender: Any) {
|
|
delegate?.showMoreOptions(forStatus: statusID)
|
|
}
|
|
|
|
}
|
|
|
|
extension StatusTableViewCell: TableViewSwipeActionProvider {
|
|
|
|
func leadingSwipeActionsConfiguration() -> UISwipeActionsConfiguration? {
|
|
guard let status = MastodonCache.status(for: statusID) else { fatalError("Missing cached status \(statusID!)") }
|
|
|
|
let favoriteTitle: String
|
|
let favoriteRequest: Request<Status>
|
|
let favoriteColor: UIColor
|
|
if status.favourited ?? false {
|
|
favoriteTitle = "Unfavorite"
|
|
favoriteRequest = Status.unfavourite(status)
|
|
favoriteColor = UIColor(displayP3Red: 235/255, green: 77/255, blue: 62/255, alpha: 1)
|
|
|
|
} else {
|
|
favoriteTitle = "Favorite"
|
|
favoriteRequest = Status.favourite(status)
|
|
favoriteColor = UIColor(displayP3Red: 1, green: 204/255, blue: 0, alpha: 1)
|
|
}
|
|
let favorite = UIContextualAction(style: .normal, title: favoriteTitle) { (action, view, completion) in
|
|
MastodonController.client.run(favoriteRequest, completion: { response in
|
|
DispatchQueue.main.async {
|
|
guard case let .success(status, _) = response else {
|
|
completion(false)
|
|
return
|
|
}
|
|
completion(true)
|
|
MastodonCache.add(status: status)
|
|
}
|
|
})
|
|
}
|
|
favorite.image = UIImage(systemName: "star.fill")
|
|
favorite.backgroundColor = favoriteColor
|
|
|
|
let reblogTitle: String
|
|
let reblogRequest: Request<Status>
|
|
let reblogColor: UIColor
|
|
if status.reblogged ?? false {
|
|
reblogTitle = "Unreblog"
|
|
reblogRequest = Status.unreblog(status)
|
|
reblogColor = UIColor(displayP3Red: 235/255, green: 77/255, blue: 62/255, alpha: 1)
|
|
} else {
|
|
reblogTitle = "Reblog"
|
|
reblogRequest = Status.reblog(status)
|
|
reblogColor = tintColor
|
|
}
|
|
let reblog = UIContextualAction(style: .normal, title: reblogTitle) { (action, view, completion) in
|
|
MastodonController.client.run(reblogRequest, completion: { response in
|
|
DispatchQueue.main.async {
|
|
guard case let .success(status, _) = response else {
|
|
completion(false)
|
|
return
|
|
}
|
|
completion(true)
|
|
MastodonCache.add(status: status)
|
|
}
|
|
})
|
|
}
|
|
reblog.image = UIImage(systemName: "repeat")
|
|
reblog.backgroundColor = reblogColor
|
|
|
|
return UISwipeActionsConfiguration(actions: [favorite, reblog])
|
|
}
|
|
|
|
func trailingSwipeActionsConfiguration() -> UISwipeActionsConfiguration? {
|
|
let reply = UIContextualAction(style: .normal, title: "Reply") { (action, view, completion) in
|
|
completion(true)
|
|
self.delegate?.reply(to: self.statusID)
|
|
}
|
|
reply.image = UIImage(systemName: "arrowshape.turn.up.left.fill")
|
|
reply.backgroundColor = tintColor
|
|
let more = UIContextualAction(style: .normal, title: "More") { (action, view, completion) in
|
|
completion(true)
|
|
self.delegate?.showMoreOptions(forStatus: self.statusID)
|
|
}
|
|
more.image = UIImage(systemName: "ellipsis")
|
|
more.backgroundColor = .gray
|
|
return UISwipeActionsConfiguration(actions: [reply, more])
|
|
}
|
|
|
|
}
|
|
|
|
extension StatusTableViewCell: AttachmentViewDelegate {
|
|
func showAttachmentsGallery(startingAt index: Int) {
|
|
guard let status = MastodonCache.status(for: statusID) else { fatalError("Missing cached status \(statusID!)") }
|
|
let sourceViews = status.attachments.map(attachmentsView.getAttachmentView(for:))
|
|
delegate?.showGallery(attachments: status.attachments, sourceViews: sourceViews, startIndex: index)
|
|
}
|
|
}
|
|
|
|
extension StatusTableViewCell: MenuPreviewProvider {
|
|
|
|
func getPreviewProviders(for location: CGPoint, sourceViewController: UIViewController) -> PreviewProviders? {
|
|
if avatarImageView.frame.contains(location) {
|
|
return (content: { ProfileTableViewController(accountID: self.accountID) }, actions: { self.actionsForProfile(accountID: self.accountID) })
|
|
} else if attachmentsView.frame.contains(location) {
|
|
let attachmentsViewLocation = attachmentsView.convert(location, from: self)
|
|
if let attachmentView = attachmentsView.subviews.first(where: { $0.frame.contains(attachmentsViewLocation) }) as? AttachmentView {
|
|
let image = attachmentView.image!
|
|
let description = attachmentView.attachment.description
|
|
return (content: { self.delegate?.largeImage(image, description: description, sourceView: attachmentView) }, actions: { [] })
|
|
}
|
|
} else if contentLabel.frame.contains(location),
|
|
let link = contentLabel.getLink(atPoint: contentLabel.convert(location, from: self)) {
|
|
return (
|
|
content: { self.contentLabel.getViewController(forLink: link.url, inRange: link.range) },
|
|
actions: {
|
|
let text = (self.contentLabel.text! as NSString).substring(with: link.range)
|
|
if let mention = self.contentLabel.getMention(for: link.url, text: text) {
|
|
return self.actionsForProfile(accountID: mention.id)
|
|
} else if let hashtag = self.contentLabel.getHashtag(for: link.url, text: text) {
|
|
return self.actionsForHashtag(hashtag)
|
|
} else {
|
|
return self.actionsForURL(link.url)
|
|
}
|
|
}
|
|
)
|
|
}
|
|
return (content: { ConversationTableViewController(for: self.statusID) }, actions: { self.actionsForStatus(statusID: self.statusID) })
|
|
}
|
|
|
|
}
|