mirror of
https://github.com/Swiftgram/Telegram-iOS.git
synced 2025-06-16 05:55:20 +00:00
364 lines
14 KiB
Swift
364 lines
14 KiB
Swift
import Foundation
|
|
import UIKit
|
|
import Display
|
|
import TelegramCore
|
|
import SwiftSignalKit
|
|
import AsyncDisplayKit
|
|
import Postbox
|
|
import AccountContext
|
|
import TelegramPresentationData
|
|
import TelegramStringFormatting
|
|
import Photos
|
|
import CheckNode
|
|
import LegacyComponents
|
|
import PhotoResources
|
|
|
|
enum MediaPickerGridItemContent: Equatable {
|
|
case asset(PHFetchResult<PHAsset>, Int)
|
|
case media(MediaPickerScreen.Subject.Media, Int)
|
|
}
|
|
|
|
final class MediaPickerGridItem: GridItem {
|
|
let content: MediaPickerGridItemContent
|
|
let interaction: MediaPickerInteraction
|
|
let theme: PresentationTheme
|
|
|
|
let section: GridSection? = nil
|
|
|
|
init(content: MediaPickerGridItemContent, interaction: MediaPickerInteraction, theme: PresentationTheme) {
|
|
self.content = content
|
|
self.interaction = interaction
|
|
self.theme = theme
|
|
}
|
|
|
|
func node(layout: GridNodeLayout, synchronousLoad: Bool) -> GridItemNode {
|
|
switch self.content {
|
|
case let .asset(fetchResult, index):
|
|
let node = MediaPickerGridItemNode()
|
|
node.setup(interaction: self.interaction, fetchResult: fetchResult, index: index, theme: self.theme)
|
|
return node
|
|
case let .media(media, index):
|
|
let node = MediaPickerGridItemNode()
|
|
node.setup(interaction: self.interaction, media: media, index: index, theme: self.theme)
|
|
return node
|
|
}
|
|
}
|
|
|
|
func update(node: GridItemNode) {
|
|
switch self.content {
|
|
case let .asset(fetchResult, index):
|
|
guard let node = node as? MediaPickerGridItemNode else {
|
|
assertionFailure()
|
|
return
|
|
}
|
|
node.setup(interaction: self.interaction, fetchResult: fetchResult, index: index, theme: self.theme)
|
|
case let .media(media, index):
|
|
guard let node = node as? MediaPickerGridItemNode else {
|
|
assertionFailure()
|
|
return
|
|
}
|
|
node.setup(interaction: self.interaction, media: media, index: index, theme: self.theme)
|
|
}
|
|
}
|
|
}
|
|
|
|
private let maskImage = generateImage(CGSize(width: 1.0, height: 24.0), opaque: false, rotatedContext: { size, context in
|
|
let bounds = CGRect(origin: CGPoint(), size: size)
|
|
context.clear(bounds)
|
|
|
|
let gradientColors = [UIColor.black.withAlphaComponent(0.0).cgColor, UIColor.black.withAlphaComponent(0.6).cgColor] as CFArray
|
|
|
|
var locations: [CGFloat] = [0.0, 1.0]
|
|
let colorSpace = CGColorSpaceCreateDeviceRGB()
|
|
let gradient = CGGradient(colorsSpace: colorSpace, colors: gradientColors, locations: &locations)!
|
|
|
|
context.drawLinearGradient(gradient, start: CGPoint(x: 0.0, y: 0.0), end: CGPoint(x: 0.0, y: size.height), options: CGGradientDrawingOptions())
|
|
})
|
|
|
|
final class MediaPickerGridItemNode: GridItemNode {
|
|
var currentMediaState: (TGMediaSelectableItem, Int)?
|
|
var currentState: (PHFetchResult<PHAsset>, Int)?
|
|
private let imageNode: ImageNode
|
|
private var checkNode: InteractiveCheckNode?
|
|
private let gradientNode: ASImageNode
|
|
private let typeIconNode: ASImageNode
|
|
private let durationNode: ImmediateTextNode
|
|
|
|
private var interaction: MediaPickerInteraction?
|
|
private var theme: PresentationTheme?
|
|
|
|
private var currentIsPreviewing = false
|
|
|
|
var selected: (() -> Void)?
|
|
|
|
override init() {
|
|
self.imageNode = ImageNode()
|
|
self.imageNode.clipsToBounds = true
|
|
self.imageNode.contentMode = .scaleAspectFill
|
|
self.imageNode.isLayerBacked = false
|
|
self.imageNode.animateFirstTransition = false
|
|
|
|
self.gradientNode = ASImageNode()
|
|
self.gradientNode.displaysAsynchronously = false
|
|
self.gradientNode.displayWithoutProcessing = true
|
|
self.gradientNode.image = maskImage
|
|
|
|
self.typeIconNode = ASImageNode()
|
|
self.typeIconNode.displaysAsynchronously = false
|
|
self.typeIconNode.displayWithoutProcessing = true
|
|
|
|
self.durationNode = ImmediateTextNode()
|
|
|
|
super.init()
|
|
|
|
self.addSubnode(self.imageNode)
|
|
}
|
|
|
|
var identifier: String {
|
|
return self.selectableItem?.uniqueIdentifier ?? ""
|
|
}
|
|
|
|
var selectableItem: TGMediaSelectableItem? {
|
|
if let (media, _) = self.currentMediaState {
|
|
return media
|
|
} else if let (fetchResult, index) = self.currentState {
|
|
return TGMediaAsset(phAsset: fetchResult[index])
|
|
} else {
|
|
return nil
|
|
}
|
|
}
|
|
|
|
var _cachedTag: Int32?
|
|
var tag: Int32? {
|
|
// if let tag = self._cachedTag {
|
|
// return tag
|
|
// } else if let asset = self.asset, let localTimestamp = asset.creationDate?.timeIntervalSince1970 {
|
|
// let tag = Month(localTimestamp: Int32(localTimestamp)).packedValue
|
|
// self._cachedTag = tag
|
|
// return tag
|
|
// } else {
|
|
return nil
|
|
// }
|
|
}
|
|
|
|
func updateSelectionState(animated: Bool = false) {
|
|
if self.checkNode == nil, let _ = self.interaction?.selectionState, let theme = self.theme {
|
|
let checkNode = InteractiveCheckNode(theme: CheckNodeTheme(theme: theme, style: .overlay))
|
|
checkNode.valueChanged = { [weak self] value in
|
|
if let strongSelf = self, let interaction = strongSelf.interaction, let selectableItem = strongSelf.selectableItem {
|
|
interaction.toggleSelection(selectableItem, value, false)
|
|
}
|
|
}
|
|
self.addSubnode(checkNode)
|
|
self.checkNode = checkNode
|
|
self.setNeedsLayout()
|
|
}
|
|
|
|
if let interaction = self.interaction, let selectionState = interaction.selectionState {
|
|
let selected = selectionState.isIdentifierSelected(self.identifier)
|
|
if let selectableItem = self.selectableItem {
|
|
let index = selectionState.index(of: selectableItem)
|
|
if index != NSNotFound {
|
|
self.checkNode?.content = .counter(Int(index))
|
|
}
|
|
}
|
|
self.checkNode?.setSelected(selected, animated: animated)
|
|
}
|
|
}
|
|
|
|
func updateHiddenMedia() {
|
|
let wasHidden = self.isHidden
|
|
self.isHidden = self.interaction?.hiddenMediaId == self.identifier
|
|
if !self.isHidden && wasHidden {
|
|
self.animateFadeIn(animateCheckNode: true)
|
|
}
|
|
}
|
|
|
|
func animateFadeIn(animateCheckNode: Bool) {
|
|
if animateCheckNode {
|
|
self.checkNode?.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.2)
|
|
}
|
|
self.gradientNode.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.2)
|
|
self.typeIconNode.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.2)
|
|
self.durationNode.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.2)
|
|
}
|
|
|
|
override func didLoad() {
|
|
super.didLoad()
|
|
|
|
self.view.addGestureRecognizer(UITapGestureRecognizer(target: self, action: #selector(self.imageNodeTap(_:))))
|
|
}
|
|
|
|
func setup(interaction: MediaPickerInteraction, media: MediaPickerScreen.Subject.Media, index: Int, theme: PresentationTheme) {
|
|
self.interaction = interaction
|
|
self.theme = theme
|
|
|
|
self.backgroundColor = theme.list.mediaPlaceholderColor
|
|
|
|
if self.currentMediaState == nil || self.currentMediaState!.0.uniqueIdentifier != media.identifier || self.currentState!.1 != index {
|
|
// let editingContext = interaction.editingState
|
|
// let asset = media.asset as? TGMediaEditableItem
|
|
//
|
|
// let editedSignal = Signal<UIImage?, NoError> { subscriber in
|
|
// if let signal = editingContext.thumbnailImageSignal(forIdentifier: media.identifier) {
|
|
// let disposable = signal.start(next: { next in
|
|
// if let image = next as? UIImage {
|
|
// subscriber.putNext(image)
|
|
// } else {
|
|
// subscriber.putNext(nil)
|
|
// }
|
|
// }, error: { _ in
|
|
// }, completed: nil)!
|
|
//
|
|
// return ActionDisposable {
|
|
// disposable.dispose()
|
|
// }
|
|
// } else {
|
|
// return EmptyDisposable
|
|
// }
|
|
// }
|
|
//
|
|
// let originalImageSignal = Signal<UIImage?, NoError> { subscriber in
|
|
// if let signal = asset?.thumbnailImageSignal?()
|
|
// }
|
|
//
|
|
// let scale = min(2.0, UIScreenScale)
|
|
// let targetSize = CGSize(width: 128.0 * scale, height: 128.0 * scale)
|
|
// let originalSignal: Signal<UIImage, NoError> = assetImage(fetchResult: fetchResult, index: index, targetSize: targetSize, exact: false)
|
|
// let imageSignal: Signal<UIImage?, NoError> = editedSignal
|
|
// |> mapToSignal { result in
|
|
// if let result = result {
|
|
// return .single(result)
|
|
// } else {
|
|
// return originalSignal
|
|
// }
|
|
// }
|
|
// self.imageNode.setSignal(imageSignal)
|
|
//
|
|
// if case .video = media, let asset = media.asset as? TGCameraCapturedVideo {
|
|
// self.typeIconNode.image = UIImage(bundleImageName: "Media Editor/MediaVideo")
|
|
//
|
|
// if self.typeIconNode.supernode == nil {
|
|
// self.durationNode.attributedText = NSAttributedString(string: stringForDuration(Int32(asset.videoDuration)), font: Font.semibold(12.0), textColor: .white)
|
|
//
|
|
// self.addSubnode(self.gradientNode)
|
|
// self.addSubnode(self.typeIconNode)
|
|
// self.addSubnode(self.durationNode)
|
|
// self.setNeedsLayout()
|
|
// }
|
|
// }
|
|
//
|
|
self.currentMediaState = (media.asset, index)
|
|
self.setNeedsLayout()
|
|
}
|
|
|
|
self.updateSelectionState()
|
|
self.updateHiddenMedia()
|
|
}
|
|
|
|
func setup(interaction: MediaPickerInteraction, fetchResult: PHFetchResult<PHAsset>, index: Int, theme: PresentationTheme) {
|
|
self.interaction = interaction
|
|
self.theme = theme
|
|
|
|
self.backgroundColor = theme.list.mediaPlaceholderColor
|
|
|
|
if self.currentState == nil || self.currentState!.0 !== fetchResult || self.currentState!.1 != index {
|
|
let editingContext = interaction.editingState
|
|
let asset = fetchResult.object(at: index)
|
|
|
|
let editedSignal = Signal<UIImage?, NoError> { subscriber in
|
|
if let signal = editingContext.thumbnailImageSignal(forIdentifier: asset.localIdentifier) {
|
|
let disposable = signal.start(next: { next in
|
|
if let image = next as? UIImage {
|
|
subscriber.putNext(image)
|
|
} else {
|
|
subscriber.putNext(nil)
|
|
}
|
|
}, error: { _ in
|
|
}, completed: nil)!
|
|
|
|
return ActionDisposable {
|
|
disposable.dispose()
|
|
}
|
|
} else {
|
|
return EmptyDisposable
|
|
}
|
|
}
|
|
|
|
let scale = min(2.0, UIScreenScale)
|
|
let targetSize = CGSize(width: 128.0 * scale, height: 128.0 * scale)
|
|
let originalSignal = assetImage(fetchResult: fetchResult, index: index, targetSize: targetSize, exact: false)
|
|
let imageSignal: Signal<UIImage?, NoError> = editedSignal
|
|
|> mapToSignal { result in
|
|
if let result = result {
|
|
return .single(result)
|
|
} else {
|
|
return originalSignal
|
|
}
|
|
}
|
|
self.imageNode.setSignal(imageSignal)
|
|
|
|
if asset.mediaType == .video {
|
|
if asset.mediaSubtypes.contains(.videoHighFrameRate) {
|
|
self.typeIconNode.image = UIImage(bundleImageName: "Media Editor/MediaSlomo")
|
|
} else if asset.mediaSubtypes.contains(.videoTimelapse) {
|
|
self.typeIconNode.image = UIImage(bundleImageName: "Media Editor/MediaTimelapse")
|
|
} else {
|
|
self.typeIconNode.image = UIImage(bundleImageName: "Media Editor/MediaVideo")
|
|
}
|
|
|
|
if self.typeIconNode.supernode == nil {
|
|
self.durationNode.attributedText = NSAttributedString(string: stringForDuration(Int32(asset.duration)), font: Font.semibold(12.0), textColor: .white)
|
|
|
|
self.addSubnode(self.gradientNode)
|
|
self.addSubnode(self.typeIconNode)
|
|
self.addSubnode(self.durationNode)
|
|
self.setNeedsLayout()
|
|
}
|
|
} else {
|
|
if self.typeIconNode.supernode != nil {
|
|
self.gradientNode.removeFromSupernode()
|
|
self.typeIconNode.removeFromSupernode()
|
|
self.durationNode.removeFromSupernode()
|
|
}
|
|
}
|
|
|
|
self.currentState = (fetchResult, index)
|
|
self.setNeedsLayout()
|
|
}
|
|
|
|
self.updateSelectionState()
|
|
self.updateHiddenMedia()
|
|
}
|
|
|
|
override func layout() {
|
|
super.layout()
|
|
|
|
self.imageNode.frame = self.bounds
|
|
self.gradientNode.frame = CGRect(x: 0.0, y: self.bounds.height - 24.0, width: self.bounds.width, height: 24.0)
|
|
self.typeIconNode.frame = CGRect(x: 0.0, y: self.bounds.height - 20.0, width: 19.0, height: 19.0)
|
|
|
|
if self.durationNode.supernode != nil {
|
|
let durationSize = self.durationNode.updateLayout(self.bounds.size)
|
|
self.durationNode.frame = CGRect(origin: CGPoint(x: self.bounds.size.width - durationSize.width - 7.0, y: self.bounds.height - durationSize.height - 5.0), size: durationSize)
|
|
}
|
|
|
|
let checkSize = CGSize(width: 29.0, height: 29.0)
|
|
self.checkNode?.frame = CGRect(origin: CGPoint(x: self.bounds.width - checkSize.width - 3.0, y: 3.0), size: checkSize)
|
|
}
|
|
|
|
func transitionView() -> UIView {
|
|
let view = self.imageNode.view.snapshotContentTree(unhide: true, keepTransform: true)!
|
|
view.frame = self.convert(self.bounds, to: nil)
|
|
return view
|
|
}
|
|
|
|
@objc func imageNodeTap(_ recognizer: UITapGestureRecognizer) {
|
|
guard let (fetchResult, index) = self.currentState else {
|
|
return
|
|
}
|
|
self.interaction?.openMedia(fetchResult, index, self.imageNode.image)
|
|
}
|
|
}
|
|
|