mirror of
https://github.com/metabolist/metatext.git
synced 2024-05-02 16:49:01 +00:00
308 lines
13 KiB
Swift
308 lines
13 KiB
Swift
// Copyright © 2020 Metabolist. All rights reserved.
|
|
|
|
import AVFoundation
|
|
import BlurHash
|
|
import Mastodon
|
|
import SDWebImage
|
|
import UIKit
|
|
import ViewModels
|
|
|
|
enum ImageError: Error {
|
|
case unableToLoad
|
|
}
|
|
|
|
extension ImageError: LocalizedError {
|
|
var errorDescription: String? {
|
|
switch self {
|
|
case .unableToLoad:
|
|
return NSLocalizedString("image-error.unable-to-load", comment: "")
|
|
}
|
|
}
|
|
}
|
|
|
|
final class ImageViewController: UIViewController {
|
|
let scrollView = UIScrollView()
|
|
let imageView = SDAnimatedImageView()
|
|
let playerView = PlayerView()
|
|
|
|
private let viewModel: AttachmentViewModel?
|
|
private let imageURL: URL?
|
|
private let contentView = UIView()
|
|
private let descriptionBackgroundView = UIVisualEffectView(effect: UIBlurEffect(style: .systemChromeMaterial))
|
|
private let descriptionTextView = UITextView()
|
|
|
|
init(viewModel: AttachmentViewModel? = nil, imageURL: URL? = nil) {
|
|
self.viewModel = viewModel
|
|
self.imageURL = imageURL
|
|
|
|
super.init(nibName: nil, bundle: nil)
|
|
}
|
|
|
|
@available(*, unavailable)
|
|
required init?(coder: NSCoder) {
|
|
fatalError("init(coder:) has not been implemented")
|
|
}
|
|
|
|
// swiftlint:disable:next function_body_length
|
|
override func viewDidLoad() {
|
|
super.viewDidLoad()
|
|
|
|
view.backgroundColor = .secondarySystemBackground
|
|
|
|
view.addSubview(scrollView)
|
|
scrollView.delegate = self
|
|
scrollView.translatesAutoresizingMaskIntoConstraints = false
|
|
scrollView.showsHorizontalScrollIndicator = false
|
|
scrollView.showsVerticalScrollIndicator = false
|
|
scrollView.maximumZoomScale = Self.maximumZoomScale
|
|
|
|
let doubleTapGestureRecognizer = UITapGestureRecognizer(
|
|
target: self,
|
|
action: #selector(handleDoubleTap(gestureRecognizer:)))
|
|
|
|
doubleTapGestureRecognizer.numberOfTapsRequired = 2
|
|
scrollView.addGestureRecognizer(doubleTapGestureRecognizer)
|
|
|
|
contentView.translatesAutoresizingMaskIntoConstraints = false
|
|
scrollView.addSubview(contentView)
|
|
|
|
contentView.addSubview(imageView)
|
|
imageView.translatesAutoresizingMaskIntoConstraints = false
|
|
imageView.contentMode = .scaleAspectFit
|
|
imageView.sd_imageIndicator = SDWebImageActivityIndicator.large
|
|
imageView.autoPlayAnimatedImage = false
|
|
|
|
contentView.addSubview(playerView)
|
|
playerView.translatesAutoresizingMaskIntoConstraints = false
|
|
|
|
view.addSubview(descriptionBackgroundView)
|
|
descriptionBackgroundView.translatesAutoresizingMaskIntoConstraints = false
|
|
descriptionBackgroundView.isHidden = viewModel?.attachment.description == nil
|
|
|| viewModel?.attachment.description == ""
|
|
|
|
descriptionBackgroundView.contentView.addSubview(descriptionTextView)
|
|
descriptionTextView.translatesAutoresizingMaskIntoConstraints = false
|
|
descriptionTextView.backgroundColor = .clear
|
|
descriptionTextView.font = .preferredFont(forTextStyle: .caption1)
|
|
descriptionTextView.adjustsFontForContentSizeCategory = true
|
|
descriptionTextView.text = viewModel?.attachment.description
|
|
descriptionTextView.isScrollEnabled = false
|
|
descriptionTextView.isEditable = false
|
|
|
|
NSLayoutConstraint.activate([
|
|
scrollView.leadingAnchor.constraint(equalTo: view.leadingAnchor),
|
|
scrollView.topAnchor.constraint(equalTo: view.topAnchor),
|
|
scrollView.trailingAnchor.constraint(equalTo: view.trailingAnchor),
|
|
scrollView.bottomAnchor.constraint(equalTo: view.bottomAnchor),
|
|
contentView.leadingAnchor.constraint(equalTo: scrollView.leadingAnchor),
|
|
contentView.topAnchor.constraint(equalTo: scrollView.topAnchor),
|
|
contentView.trailingAnchor.constraint(equalTo: scrollView.trailingAnchor),
|
|
contentView.bottomAnchor.constraint(equalTo: scrollView.bottomAnchor),
|
|
contentView.centerXAnchor.constraint(equalTo: scrollView.centerXAnchor),
|
|
contentView.centerYAnchor.constraint(equalTo: scrollView.centerYAnchor),
|
|
imageView.leadingAnchor.constraint(equalTo: contentView.leadingAnchor),
|
|
imageView.topAnchor.constraint(equalTo: contentView.topAnchor),
|
|
imageView.trailingAnchor.constraint(equalTo: contentView.trailingAnchor),
|
|
imageView.bottomAnchor.constraint(equalTo: contentView.bottomAnchor),
|
|
playerView.leadingAnchor.constraint(equalTo: contentView.leadingAnchor),
|
|
playerView.topAnchor.constraint(equalTo: contentView.topAnchor),
|
|
playerView.trailingAnchor.constraint(equalTo: contentView.trailingAnchor),
|
|
playerView.bottomAnchor.constraint(equalTo: contentView.bottomAnchor),
|
|
descriptionBackgroundView.leadingAnchor.constraint(equalTo: view.leadingAnchor),
|
|
descriptionBackgroundView.trailingAnchor.constraint(equalTo: view.trailingAnchor),
|
|
descriptionBackgroundView.bottomAnchor.constraint(equalTo: view.bottomAnchor),
|
|
descriptionTextView.heightAnchor.constraint(lessThanOrEqualTo: view.heightAnchor, multiplier: 1 / 4),
|
|
descriptionTextView.leadingAnchor.constraint(
|
|
equalTo: descriptionBackgroundView.layoutMarginsGuide.leadingAnchor),
|
|
descriptionTextView.topAnchor.constraint(equalTo: descriptionBackgroundView.topAnchor),
|
|
descriptionTextView.trailingAnchor.constraint(
|
|
equalTo: descriptionBackgroundView.layoutMarginsGuide.trailingAnchor),
|
|
descriptionTextView.bottomAnchor.constraint(equalTo: view.safeAreaLayoutGuide.bottomAnchor)
|
|
])
|
|
|
|
if let viewModel = viewModel {
|
|
switch viewModel.attachment.type {
|
|
case .image:
|
|
imageView.tag = viewModel.tag
|
|
playerView.isHidden = true
|
|
|
|
let placeholderImage: UIImage?
|
|
let cachedImageKey = viewModel.attachment.previewUrl?.url.absoluteString
|
|
let cachedImage = SDImageCache.shared.imageFromCache(forKey: cachedImageKey)
|
|
|
|
if cachedImage != nil {
|
|
placeholderImage = cachedImage
|
|
imageView.sd_imageIndicator = nil
|
|
} else if let blurHash = viewModel.attachment.blurhash {
|
|
placeholderImage = UIImage(blurHash: blurHash, size: .blurHashSize)
|
|
} else {
|
|
placeholderImage = nil
|
|
}
|
|
|
|
imageView.sd_setImage(with: viewModel.attachment.url.url,
|
|
placeholderImage: placeholderImage) { [weak self] _, error, _, _ in
|
|
if error != nil {
|
|
let alertItem = AlertItem(error: ImageError.unableToLoad)
|
|
|
|
self?.present(alertItem: alertItem)
|
|
}
|
|
}
|
|
case .gifv:
|
|
playerView.tag = viewModel.tag
|
|
imageView.isHidden = true
|
|
let player = PlayerCache.shared.player(url: viewModel.attachment.url.url)
|
|
|
|
player.isMuted = true
|
|
|
|
playerView.player = player
|
|
player.play()
|
|
default: break
|
|
}
|
|
|
|
var accessibilityLabel = viewModel.attachment.type.accessibilityName
|
|
|
|
if let description = viewModel.attachment.description {
|
|
accessibilityLabel.appendWithSeparator(description)
|
|
}
|
|
} else if let imageURL = imageURL {
|
|
imageView.tag = imageURL.hashValue
|
|
playerView.isHidden = true
|
|
imageView.sd_setImage(with: imageURL)
|
|
}
|
|
|
|
contentView.accessibilityLabel = viewModel?.attachment.type.accessibilityName
|
|
?? Attachment.AttachmentType.image.accessibilityName
|
|
contentView.isAccessibilityElement = true
|
|
}
|
|
|
|
override func viewDidLayoutSubviews() {
|
|
super.viewDidLayoutSubviews()
|
|
|
|
let textHeight = descriptionTextView.sizeThatFits(.init(
|
|
width: descriptionTextView.frame.width,
|
|
height: .greatestFiniteMagnitude)).height
|
|
descriptionTextView.isScrollEnabled = textHeight > descriptionTextView.frame.height
|
|
}
|
|
}
|
|
|
|
extension ImageViewController {
|
|
func toggleDescriptionVisibility() {
|
|
UIView.animate(withDuration: .shortAnimationDuration) {
|
|
self.descriptionBackgroundView.alpha = self.descriptionBackgroundView.alpha > 0 ? 0 : 1
|
|
}
|
|
}
|
|
|
|
func presentActivityViewController() {
|
|
if let imageData = imageView.image?.sd_imageData(), let url = imageURL ?? viewModel?.attachment.url.url {
|
|
let tempURL = URL(fileURLWithPath: NSTemporaryDirectory(), isDirectory: true)
|
|
.appendingPathComponent(url.lastPathComponent)
|
|
|
|
do {
|
|
try imageData.write(to: tempURL)
|
|
|
|
let activityViewController = UIActivityViewController(
|
|
activityItems: [tempURL],
|
|
applicationActivities: [])
|
|
|
|
if UIDevice.current.userInterfaceIdiom == .pad {
|
|
activityViewController.popoverPresentationController?
|
|
.barButtonItem = parent?.navigationItem.rightBarButtonItem
|
|
}
|
|
|
|
present(activityViewController, animated: true)
|
|
} catch {
|
|
alertUnableToExportMedia()
|
|
}
|
|
} else if let asset = playerView.player?.currentItem?.asset as? AVURLAsset {
|
|
asset.exportWithoutAudioTrack { result in
|
|
DispatchQueue.main.async {
|
|
switch result {
|
|
case let .success(url):
|
|
let activityViewController = UIActivityViewController(
|
|
activityItems: [url],
|
|
applicationActivities: [])
|
|
|
|
if UIDevice.current.userInterfaceIdiom == .pad {
|
|
activityViewController.popoverPresentationController?
|
|
.barButtonItem = self.parent?.navigationItem.rightBarButtonItem
|
|
}
|
|
|
|
activityViewController.completionWithItemsHandler = { _, _, _, _ in
|
|
try? FileManager.default.removeItem(at: url.deletingLastPathComponent())
|
|
}
|
|
|
|
self.present(activityViewController, animated: true)
|
|
case .failure:
|
|
self.alertUnableToExportMedia()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
extension ImageViewController: UIScrollViewDelegate {
|
|
func viewForZooming(in scrollView: UIScrollView) -> UIView? {
|
|
contentView
|
|
}
|
|
|
|
// https://stackoverflow.com/a/40480610/2484482
|
|
func scrollViewDidZoom(_ scrollView: UIScrollView) {
|
|
if scrollView.zoomScale > 1,
|
|
let contentSize = imageView.image?.size ?? playerView.player?.currentItem?.presentationSize {
|
|
let ratio = min(contentView.frame.width / contentSize.width, contentView.frame.height / contentSize.height)
|
|
|
|
let newWidth = contentSize.width * ratio
|
|
let newHeight = contentSize.height * ratio
|
|
|
|
let horizontalInset = 0.5 * (newWidth * scrollView.zoomScale > contentView.frame.width
|
|
? (newWidth - contentView.frame.width)
|
|
: (scrollView.frame.width - scrollView.contentSize.width))
|
|
let verticalInset = 0.5 * (newHeight * scrollView.zoomScale > contentView.frame.height
|
|
? (newHeight - contentView.frame.height)
|
|
: (scrollView.frame.height - scrollView.contentSize.height))
|
|
|
|
scrollView.contentInset = .init(
|
|
top: verticalInset,
|
|
left: horizontalInset,
|
|
bottom: verticalInset,
|
|
right: horizontalInset)
|
|
} else {
|
|
scrollView.contentInset = .zero
|
|
}
|
|
}
|
|
}
|
|
|
|
private extension ImageViewController {
|
|
static let maximumZoomScale: CGFloat = 4
|
|
|
|
@objc func handleDoubleTap(gestureRecognizer: UITapGestureRecognizer) {
|
|
if scrollView.zoomScale == scrollView.minimumZoomScale {
|
|
let width = contentView.frame.size.width / scrollView.maximumZoomScale
|
|
let height = contentView.frame.size.height / scrollView.maximumZoomScale
|
|
let center = scrollView.convert(gestureRecognizer.location(in: gestureRecognizer.view), from: contentView)
|
|
|
|
scrollView.zoom(
|
|
to: CGRect(x: center.x - (width / 2), y: center.y - (height / 2), width: width, height: height),
|
|
animated: true)
|
|
} else {
|
|
scrollView.setZoomScale(scrollView.minimumZoomScale, animated: true)
|
|
}
|
|
}
|
|
|
|
func alertUnableToExportMedia() {
|
|
let alertController = UIAlertController(
|
|
title: nil,
|
|
message: NSLocalizedString("attachment.unable-to-export-media", comment: ""),
|
|
preferredStyle: .alert)
|
|
|
|
let okAction = UIAlertAction(
|
|
title: NSLocalizedString("ok", comment: ""),
|
|
style: .default) { _ in }
|
|
|
|
alertController.addAction(okAction)
|
|
|
|
self.present(alertController, animated: true)
|
|
}
|
|
}
|