638 lines
27 KiB
Swift
638 lines
27 KiB
Swift
// Copyright © 2022 Rangeproof Pty Ltd. All rights reserved.
|
|
|
|
import Foundation
|
|
import GRDB
|
|
import DifferenceKit
|
|
import SignalUtilitiesKit
|
|
import SessionUtilitiesKit
|
|
|
|
public class MediaGalleryViewModel {
|
|
public typealias SectionModel = ArraySection<Section, Item>
|
|
|
|
// MARK: - Section
|
|
|
|
public enum Section: Differentiable, Equatable, Comparable, Hashable {
|
|
case emptyGallery
|
|
case loadOlder
|
|
case galleryMonth(date: GalleryDate)
|
|
case loadNewer
|
|
}
|
|
|
|
// MARK: Media type
|
|
public enum MediaType {
|
|
case media
|
|
case document
|
|
}
|
|
|
|
// MARK: - Variables
|
|
|
|
public let threadId: String
|
|
public let threadVariant: SessionThread.Variant
|
|
private var focusedAttachmentId: String?
|
|
public private(set) var focusedIndexPath: IndexPath?
|
|
public var mediaType: MediaType
|
|
|
|
/// This value is the current state of an album view
|
|
private var cachedInteractionIdBefore: Atomic<[Int64: Int64]> = Atomic([:])
|
|
private var cachedInteractionIdAfter: Atomic<[Int64: Int64]> = Atomic([:])
|
|
|
|
public var interactionIdBefore: [Int64: Int64] { cachedInteractionIdBefore.wrappedValue }
|
|
public var interactionIdAfter: [Int64: Int64] { cachedInteractionIdAfter.wrappedValue }
|
|
public private(set) var albumData: [Int64: [Item]] = [:]
|
|
public private(set) var pagedDataObserver: PagedDatabaseObserver<Attachment, Item>?
|
|
|
|
/// This value is the current state of a gallery view
|
|
private var unobservedGalleryDataChanges: ([SectionModel], StagedChangeset<[SectionModel]>)?
|
|
public private(set) var galleryData: [SectionModel] = []
|
|
public var onGalleryChange: (([SectionModel], StagedChangeset<[SectionModel]>) -> ())? {
|
|
didSet {
|
|
// When starting to observe interaction changes we want to trigger a UI update just in case the
|
|
// data was changed while we weren't observing
|
|
if let changes: ([SectionModel], StagedChangeset<[SectionModel]>) = self.unobservedGalleryDataChanges {
|
|
let performChange: (([SectionModel], StagedChangeset<[SectionModel]>) -> ())? = onGalleryChange
|
|
|
|
switch Thread.isMainThread {
|
|
case true: performChange?(changes.0, changes.1)
|
|
case false: DispatchQueue.main.async { performChange?(changes.0, changes.1) }
|
|
}
|
|
|
|
self.unobservedGalleryDataChanges = nil
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - Initialization
|
|
|
|
init(
|
|
threadId: String,
|
|
threadVariant: SessionThread.Variant,
|
|
isPagedData: Bool,
|
|
mediaType: MediaType,
|
|
pageSize: Int = 1,
|
|
focusedAttachmentId: String? = nil,
|
|
performInitialQuerySync: Bool = false
|
|
) {
|
|
self.threadId = threadId
|
|
self.threadVariant = threadVariant
|
|
self.focusedAttachmentId = focusedAttachmentId
|
|
self.pagedDataObserver = nil
|
|
self.mediaType = mediaType
|
|
|
|
guard isPagedData else { return }
|
|
|
|
// Note: Since this references self we need to finish initializing before setting it, we
|
|
// also want to skip the initial query and trigger it async so that the push animation
|
|
// doesn't stutter (it should load basically immediately but without this there is a
|
|
// distinct stutter)
|
|
self.pagedDataObserver = PagedDatabaseObserver(
|
|
pagedTable: Attachment.self,
|
|
pageSize: pageSize,
|
|
idColumn: .id,
|
|
observedChanges: [
|
|
PagedData.ObservedChanges(
|
|
table: Attachment.self,
|
|
columns: [.isValid]
|
|
)
|
|
],
|
|
joinSQL: Item.joinSQL,
|
|
filterSQL: Item.filterSQL(threadId: threadId, mediaType: self.mediaType),
|
|
orderSQL: Item.galleryOrderSQL,
|
|
dataQuery: Item.baseQuery(orderSQL: Item.galleryOrderSQL),
|
|
onChangeUnsorted: { [weak self] updatedData, updatedPageInfo in
|
|
PagedData.processAndTriggerUpdates(
|
|
updatedData: self?.process(data: updatedData, for: updatedPageInfo),
|
|
currentDataRetriever: { self?.galleryData },
|
|
onDataChange: self?.onGalleryChange,
|
|
onUnobservedDataChange: { updatedData, changeset in
|
|
self?.unobservedGalleryDataChanges = (changeset.isEmpty ?
|
|
nil :
|
|
(updatedData, changeset)
|
|
)
|
|
}
|
|
)
|
|
}
|
|
)
|
|
|
|
// Run the initial query on a backgorund thread so we don't block the push transition
|
|
let loadInitialData: () -> () = { [weak self] in
|
|
// If we don't have a `initialFocusedId` then default to `.pageBefore` (it'll query
|
|
// from a `0` offset)
|
|
guard let initialFocusedId: String = focusedAttachmentId else {
|
|
self?.pagedDataObserver?.load(.pageBefore)
|
|
return
|
|
}
|
|
|
|
self?.pagedDataObserver?.load(.initialPageAround(id: initialFocusedId))
|
|
}
|
|
|
|
// We have a custom transition when going from an attachment detail screen to the tile gallery
|
|
// so in that case we want to perform the initial query synchronously so that we have the content
|
|
// to do the transition (we don't clear the 'unobservedGalleryDataChanges' after setting it as
|
|
// we don't want to mess with the initial view controller behaviour)
|
|
guard !performInitialQuerySync else {
|
|
loadInitialData()
|
|
updateGalleryData(self.unobservedGalleryDataChanges?.0 ?? [])
|
|
return
|
|
}
|
|
|
|
DispatchQueue.global(qos: .userInitiated).async {
|
|
loadInitialData()
|
|
}
|
|
}
|
|
|
|
// MARK: - Data
|
|
|
|
public struct GalleryDate: Differentiable, Equatable, Comparable, Hashable {
|
|
private static let thisYearFormatter: DateFormatter = {
|
|
let formatter = DateFormatter()
|
|
formatter.dateFormat = "MMMM" // stringlint:disable
|
|
|
|
return formatter
|
|
}()
|
|
|
|
private static let olderFormatter: DateFormatter = {
|
|
// FIXME: localize for RTL, or is there a built in way to do this?
|
|
let formatter = DateFormatter()
|
|
formatter.dateFormat = "MMMM yyyy" // stringlint:disable
|
|
|
|
return formatter
|
|
}()
|
|
|
|
let year: Int
|
|
let month: Int
|
|
|
|
private var date: Date? {
|
|
var components = DateComponents()
|
|
components.month = self.month
|
|
components.year = self.year
|
|
|
|
return Calendar.current.date(from: components)
|
|
}
|
|
|
|
var localizedString: String {
|
|
let isSameMonth: Bool = (self.month == Calendar.current.component(.month, from: Date()))
|
|
let isCurrentYear: Bool = (self.year == Calendar.current.component(.year, from: Date()))
|
|
let galleryDate: Date = (self.date ?? Date())
|
|
|
|
switch (isSameMonth, isCurrentYear) {
|
|
case (true, true): return "MEDIA_GALLERY_THIS_MONTH_HEADER".localized()
|
|
case (false, true): return GalleryDate.thisYearFormatter.string(from: galleryDate)
|
|
default: return GalleryDate.olderFormatter.string(from: galleryDate)
|
|
}
|
|
}
|
|
|
|
// MARK: - --Initialization
|
|
|
|
init(messageDate: Date) {
|
|
self.year = Calendar.current.component(.year, from: messageDate)
|
|
self.month = Calendar.current.component(.month, from: messageDate)
|
|
}
|
|
|
|
// MARK: - --Comparable
|
|
|
|
public static func < (lhs: GalleryDate, rhs: GalleryDate) -> Bool {
|
|
switch ((lhs.year != rhs.year), (lhs.month != rhs.month)) {
|
|
case (true, _): return lhs.year < rhs.year
|
|
case (_, true): return lhs.month < rhs.month
|
|
default: return false
|
|
}
|
|
}
|
|
}
|
|
|
|
public struct Item: FetchableRecordWithRowId, Decodable, Identifiable, Differentiable, Equatable, Hashable, ColumnExpressible {
|
|
public typealias Columns = CodingKeys
|
|
public enum CodingKeys: String, CodingKey, ColumnExpression, CaseIterable {
|
|
case interactionId
|
|
case interactionVariant
|
|
case interactionAuthorId
|
|
case interactionTimestampMs
|
|
|
|
case rowId
|
|
case attachmentAlbumIndex
|
|
case attachment
|
|
}
|
|
|
|
public var id: String { attachment.id }
|
|
public var differenceIdentifier: String { attachment.id }
|
|
|
|
let interactionId: Int64
|
|
let interactionVariant: Interaction.Variant
|
|
let interactionAuthorId: String
|
|
let interactionTimestampMs: Int64
|
|
|
|
public var rowId: Int64
|
|
let attachmentAlbumIndex: Int
|
|
let attachment: Attachment
|
|
|
|
var galleryDate: GalleryDate {
|
|
GalleryDate(
|
|
messageDate: Date(timeIntervalSince1970: (Double(interactionTimestampMs) / 1000))
|
|
)
|
|
}
|
|
|
|
var isVideo: Bool { attachment.isVideo }
|
|
var isAnimated: Bool { attachment.isAnimated }
|
|
var isImage: Bool { attachment.isImage }
|
|
|
|
var imageSize: CGSize {
|
|
guard let width: UInt = attachment.width, let height: UInt = attachment.height else {
|
|
return .zero
|
|
}
|
|
|
|
return CGSize(width: Int(width), height: Int(height))
|
|
}
|
|
|
|
var captionForDisplay: String? { attachment.caption?.filterForDisplay }
|
|
|
|
// MARK: - Query
|
|
|
|
fileprivate static let joinSQL: SQL = {
|
|
let attachment: TypedTableAlias<Attachment> = TypedTableAlias()
|
|
let interaction: TypedTableAlias<Interaction> = TypedTableAlias()
|
|
let interactionAttachment: TypedTableAlias<InteractionAttachment> = TypedTableAlias()
|
|
|
|
return """
|
|
JOIN \(InteractionAttachment.self) ON \(interactionAttachment[.attachmentId]) = \(attachment[.id])
|
|
JOIN \(Interaction.self) ON \(interaction[.id]) = \(interactionAttachment[.interactionId])
|
|
"""
|
|
}()
|
|
|
|
fileprivate static func filterSQL(threadId: String, mediaType: MediaType) -> SQL {
|
|
let interaction: TypedTableAlias<Interaction> = TypedTableAlias()
|
|
let attachment: TypedTableAlias<Attachment> = TypedTableAlias()
|
|
|
|
switch (mediaType) {
|
|
case .media:
|
|
return SQL("""
|
|
\(attachment[.isVisualMedia]) = true AND
|
|
\(attachment[.isValid]) = true AND
|
|
\(interaction[.threadId]) = \(threadId)
|
|
""")
|
|
case .document:
|
|
// FIXME: Remove "\(attachment[.sourceFilename]) <> 'session-audio-message'" when all platforms send the voice message properly
|
|
return SQL("""
|
|
\(attachment[.isVisualMedia]) = false AND
|
|
\(attachment[.isValid]) = true AND
|
|
\(interaction[.threadId]) = \(threadId) AND
|
|
\(attachment[.variant]) = \(Attachment.Variant.standard) AND
|
|
\(attachment[.sourceFilename]) <> 'session-audio-message'
|
|
""")
|
|
}
|
|
}
|
|
|
|
fileprivate static let galleryOrderSQL: SQL = {
|
|
let interaction: TypedTableAlias<Interaction> = TypedTableAlias()
|
|
let interactionAttachment: TypedTableAlias<InteractionAttachment> = TypedTableAlias()
|
|
|
|
/// **Note:** This **MUST** match the desired sort behaviour for the screen otherwise paging will be
|
|
/// very broken
|
|
return SQL("\(interaction[.timestampMs].desc), \(interactionAttachment[.albumIndex])")
|
|
}()
|
|
|
|
fileprivate static let galleryReverseOrderSQL: SQL = {
|
|
let interaction: TypedTableAlias<Interaction> = TypedTableAlias()
|
|
let interactionAttachment: TypedTableAlias<InteractionAttachment> = TypedTableAlias()
|
|
|
|
/// **Note:** This **MUST** match the desired sort behaviour for the screen otherwise paging will be
|
|
/// very broken
|
|
return SQL("\(interaction[.timestampMs]), \(interactionAttachment[.albumIndex].desc)")
|
|
}()
|
|
|
|
fileprivate static func baseQuery(orderSQL: SQL, customFilters: SQL? = nil) -> (([Int64]) -> AdaptedFetchRequest<SQLRequest<Item>>) {
|
|
return { rowIds -> AdaptedFetchRequest<SQLRequest<Item>> in
|
|
let attachment: TypedTableAlias<Attachment> = TypedTableAlias()
|
|
let interaction: TypedTableAlias<Interaction> = TypedTableAlias()
|
|
let interactionAttachment: TypedTableAlias<InteractionAttachment> = TypedTableAlias()
|
|
|
|
let numColumnsBeforeLinkedRecords: Int = 6
|
|
let finalFilterSQL: SQL = {
|
|
guard let customFilters: SQL = customFilters else {
|
|
return """
|
|
WHERE \(attachment[.rowId]) IN \(rowIds)
|
|
"""
|
|
}
|
|
|
|
return """
|
|
WHERE (
|
|
\(customFilters)
|
|
)
|
|
"""
|
|
}()
|
|
let request: SQLRequest<Item> = """
|
|
SELECT
|
|
\(interaction[.id]) AS \(Item.Columns.interactionId),
|
|
\(interaction[.variant]) AS \(Item.Columns.interactionVariant),
|
|
\(interaction[.authorId]) AS \(Item.Columns.interactionAuthorId),
|
|
\(interaction[.timestampMs]) AS \(Item.Columns.interactionTimestampMs),
|
|
|
|
\(attachment[.rowId]) AS \(Item.Columns.rowId),
|
|
\(interactionAttachment[.albumIndex]) AS \(Item.Columns.attachmentAlbumIndex),
|
|
\(attachment.allColumns)
|
|
FROM \(Attachment.self)
|
|
\(joinSQL)
|
|
\(finalFilterSQL)
|
|
ORDER BY \(orderSQL)
|
|
"""
|
|
|
|
return request.adapted { db in
|
|
let adapters = try splittingRowAdapters(columnCounts: [
|
|
numColumnsBeforeLinkedRecords,
|
|
Attachment.numberOfSelectedColumns(db)
|
|
])
|
|
|
|
return ScopeAdapter.with(Item.self, [
|
|
.attachment: adapters[1]
|
|
])
|
|
}
|
|
}
|
|
}
|
|
|
|
fileprivate static func baseQuery(orderSQL: SQL, customFilters: SQL) -> AdaptedFetchRequest<SQLRequest<Item>> {
|
|
return Item.baseQuery(orderSQL: orderSQL, customFilters: customFilters)([])
|
|
}
|
|
|
|
func thumbnailImage(async: @escaping (UIImage) -> ()) {
|
|
attachment.thumbnail(size: .small, success: { image, _ in async(image) }, failure: {})
|
|
}
|
|
}
|
|
|
|
// MARK: - Album
|
|
|
|
/// This is all the data the screen needs to populate itself, please see the following link for tips to help optimise
|
|
/// performance https://github.com/groue/GRDB.swift#valueobservation-performance
|
|
///
|
|
/// **Note:** The 'trackingConstantRegion' is optimised in such a way that the request needs to be static
|
|
/// otherwise there may be situations where it doesn't get updates, this means we can't have conditional queries
|
|
///
|
|
/// **Note:** This observation will be triggered twice immediately (and be de-duped by the `removeDuplicates`)
|
|
/// this is due to the behaviour of `ValueConcurrentObserver.asyncStartObservation` which triggers it's own
|
|
/// fetch (after the ones in `ValueConcurrentObserver.asyncStart`/`ValueConcurrentObserver.syncStart`)
|
|
/// just in case the database has changed between the two reads - unfortunately it doesn't look like there is a way to prevent this
|
|
public typealias AlbumObservation = ValueObservation<ValueReducers.Trace<ValueReducers.RemoveDuplicates<ValueReducers.Fetch<[Item]>>>>
|
|
public lazy var observableAlbumData: AlbumObservation = buildAlbumObservation(for: nil)
|
|
|
|
private func buildAlbumObservation(for interactionId: Int64?) -> AlbumObservation {
|
|
return ValueObservation
|
|
.trackingConstantRegion { db -> [Item] in
|
|
guard let interactionId: Int64 = interactionId else { return [] }
|
|
|
|
let attachment: TypedTableAlias<Attachment> = TypedTableAlias()
|
|
let interaction: TypedTableAlias<Interaction> = TypedTableAlias()
|
|
let interactionAttachment: TypedTableAlias<InteractionAttachment> = TypedTableAlias()
|
|
|
|
return try Item
|
|
.baseQuery(
|
|
orderSQL: SQL(interactionAttachment[.albumIndex]),
|
|
customFilters: SQL("""
|
|
\(attachment[.isValid]) = true AND
|
|
\(interaction[.id]) = \(interactionId)
|
|
""")
|
|
)
|
|
.fetchAll(db)
|
|
}
|
|
.removeDuplicates()
|
|
.handleEvents(didFail: { SNLog("[MediaGalleryViewModel] Observation failed with error: \($0)") })
|
|
}
|
|
|
|
@discardableResult public func loadAndCacheAlbumData(for interactionId: Int64, in threadId: String) -> [Item] {
|
|
typealias AlbumInfo = (albumData: [Item], interactionIdBefore: Int64?, interactionIdAfter: Int64?)
|
|
|
|
// Note: It's possible we already have cached album data for this interaction
|
|
// but to avoid displaying stale data we re-fetch from the database anyway
|
|
let maybeAlbumInfo: AlbumInfo? = Storage.shared.read { db -> AlbumInfo in
|
|
let attachment: TypedTableAlias<Attachment> = TypedTableAlias()
|
|
let interaction: TypedTableAlias<Interaction> = TypedTableAlias()
|
|
let interactionAttachment: TypedTableAlias<InteractionAttachment> = TypedTableAlias()
|
|
|
|
let newAlbumData: [Item] = try Item
|
|
.baseQuery(
|
|
orderSQL: SQL(interactionAttachment[.albumIndex]),
|
|
customFilters: SQL("""
|
|
\(attachment[.isVisualMedia]) = true AND
|
|
\(attachment[.isValid]) = true AND
|
|
\(interaction[.id]) = \(interactionId)
|
|
""")
|
|
)
|
|
.fetchAll(db)
|
|
|
|
guard let albumTimestampMs: Int64 = newAlbumData.first?.interactionTimestampMs else {
|
|
return (newAlbumData, nil, nil)
|
|
}
|
|
|
|
let itemBefore: Item? = try Item
|
|
.baseQuery(
|
|
orderSQL: Item.galleryReverseOrderSQL,
|
|
customFilters: SQL("""
|
|
\(attachment[.isVisualMedia]) = true AND
|
|
\(attachment[.isValid]) = true AND
|
|
\(interaction[.timestampMs]) > \(albumTimestampMs) AND
|
|
\(interaction[.threadId]) = \(threadId)
|
|
""")
|
|
)
|
|
.fetchOne(db)
|
|
let itemAfter: Item? = try Item
|
|
.baseQuery(
|
|
orderSQL: Item.galleryOrderSQL,
|
|
customFilters: SQL("""
|
|
\(attachment[.isVisualMedia]) = true AND
|
|
\(attachment[.isValid]) = true AND
|
|
\(interaction[.timestampMs]) < \(albumTimestampMs) AND
|
|
\(interaction[.threadId]) = \(threadId)
|
|
""")
|
|
)
|
|
.fetchOne(db)
|
|
|
|
return (newAlbumData, itemBefore?.interactionId, itemAfter?.interactionId)
|
|
}
|
|
|
|
guard let newAlbumInfo: AlbumInfo = maybeAlbumInfo else { return [] }
|
|
|
|
// Cache the album info for the new interactionId
|
|
self.updateAlbumData(newAlbumInfo.albumData, for: interactionId)
|
|
self.cachedInteractionIdBefore.mutate { $0[interactionId] = newAlbumInfo.interactionIdBefore }
|
|
self.cachedInteractionIdAfter.mutate { $0[interactionId] = newAlbumInfo.interactionIdAfter }
|
|
|
|
return newAlbumInfo.albumData
|
|
}
|
|
|
|
public func replaceAlbumObservation(toObservationFor interactionId: Int64) {
|
|
self.observableAlbumData = self.buildAlbumObservation(for: interactionId)
|
|
}
|
|
|
|
public func updateAlbumData(_ updatedData: [Item], for interactionId: Int64) {
|
|
self.albumData[interactionId] = updatedData
|
|
}
|
|
|
|
// MARK: - Gallery
|
|
|
|
private func process(data: [Item], for pageInfo: PagedData.PageInfo) -> [SectionModel] {
|
|
let galleryData: [SectionModel] = data
|
|
.grouped(by: \.galleryDate)
|
|
.mapValues { sectionItems -> [Item] in
|
|
sectionItems
|
|
.sorted { lhs, rhs -> Bool in
|
|
if lhs.interactionTimestampMs == rhs.interactionTimestampMs {
|
|
// Start of album first
|
|
return (lhs.attachmentAlbumIndex < rhs.attachmentAlbumIndex)
|
|
}
|
|
|
|
// Newer interactions first
|
|
return (lhs.interactionTimestampMs > rhs.interactionTimestampMs)
|
|
}
|
|
}
|
|
.map { galleryDate, items in
|
|
SectionModel(model: .galleryMonth(date: galleryDate), elements: items)
|
|
}
|
|
|
|
// Remove and re-add the custom sections as needed
|
|
return [
|
|
(data.isEmpty ? [SectionModel(section: .emptyGallery)] : []),
|
|
(!data.isEmpty && pageInfo.pageOffset > 0 ? [SectionModel(section: .loadNewer)] : []),
|
|
galleryData,
|
|
(!data.isEmpty && (pageInfo.pageOffset + pageInfo.currentCount) < pageInfo.totalCount ?
|
|
[SectionModel(section: .loadOlder)] :
|
|
[]
|
|
)
|
|
]
|
|
.flatMap { $0 }
|
|
.sorted { lhs, rhs -> Bool in (lhs.model > rhs.model) }
|
|
}
|
|
|
|
public func updateGalleryData(_ updatedData: [SectionModel]) {
|
|
self.galleryData = updatedData
|
|
|
|
// If we have a focused attachment id then we need to make sure the 'focusedIndexPath'
|
|
// is updated to be accurate
|
|
if let focusedAttachmentId: String = focusedAttachmentId {
|
|
self.focusedIndexPath = nil
|
|
|
|
for (section, sectionData) in updatedData.enumerated() {
|
|
for (index, item) in sectionData.elements.enumerated() {
|
|
if item.attachment.id == focusedAttachmentId {
|
|
self.focusedIndexPath = IndexPath(item: index, section: section)
|
|
break
|
|
}
|
|
}
|
|
|
|
if self.focusedIndexPath != nil { break }
|
|
}
|
|
}
|
|
}
|
|
|
|
public func updateFocusedItem(attachmentId: String, indexPath: IndexPath) {
|
|
// Note: We need to set both of these as the 'focusedIndexPath' is usually
|
|
// derived and if the data changes it will be regenerated using the
|
|
// 'focusedAttachmentId' value
|
|
self.focusedAttachmentId = attachmentId
|
|
self.focusedIndexPath = indexPath
|
|
}
|
|
|
|
// MARK: - Creation Functions
|
|
|
|
public static func createDetailViewController(
|
|
for threadId: String,
|
|
threadVariant: SessionThread.Variant,
|
|
interactionId: Int64,
|
|
selectedAttachmentId: String,
|
|
options: [MediaGalleryOption]
|
|
) -> UIViewController? {
|
|
// Load the data for the album immediately (needed before pushing to the screen so
|
|
// transitions work nicely)
|
|
let viewModel: MediaGalleryViewModel = MediaGalleryViewModel(
|
|
threadId: threadId,
|
|
threadVariant: threadVariant,
|
|
isPagedData: false,
|
|
mediaType: .media
|
|
)
|
|
viewModel.loadAndCacheAlbumData(for: interactionId, in: threadId)
|
|
viewModel.replaceAlbumObservation(toObservationFor: interactionId)
|
|
|
|
guard
|
|
!viewModel.albumData.isEmpty,
|
|
let initialItem: Item = viewModel.albumData[interactionId]?.first(where: { item -> Bool in
|
|
item.attachment.id == selectedAttachmentId
|
|
})
|
|
else { return nil }
|
|
|
|
let pageViewController: MediaPageViewController = MediaPageViewController(
|
|
viewModel: viewModel,
|
|
initialItem: initialItem,
|
|
options: options
|
|
)
|
|
let navController: MediaGalleryNavigationController = MediaGalleryNavigationController()
|
|
navController.viewControllers = [pageViewController]
|
|
navController.modalPresentationStyle = .fullScreen
|
|
navController.transitioningDelegate = pageViewController
|
|
|
|
return navController
|
|
}
|
|
|
|
public static func createMediaTileViewController(
|
|
threadId: String,
|
|
threadVariant: SessionThread.Variant,
|
|
focusedAttachmentId: String?,
|
|
performInitialQuerySync: Bool = false
|
|
) -> MediaTileViewController {
|
|
let viewModel: MediaGalleryViewModel = MediaGalleryViewModel(
|
|
threadId: threadId,
|
|
threadVariant: threadVariant,
|
|
isPagedData: true,
|
|
mediaType: .media,
|
|
pageSize: MediaTileViewController.itemPageSize,
|
|
focusedAttachmentId: focusedAttachmentId,
|
|
performInitialQuerySync: performInitialQuerySync
|
|
)
|
|
|
|
return MediaTileViewController(
|
|
viewModel: viewModel
|
|
)
|
|
}
|
|
|
|
public static func createDocumentTitleViewController(
|
|
threadId: String,
|
|
threadVariant: SessionThread.Variant,
|
|
focusedAttachmentId: String?,
|
|
performInitialQuerySync: Bool = false
|
|
) -> DocumentTileViewController {
|
|
let viewModel: MediaGalleryViewModel = MediaGalleryViewModel(
|
|
threadId: threadId,
|
|
threadVariant: threadVariant,
|
|
isPagedData: true,
|
|
mediaType: .document,
|
|
pageSize: MediaTileViewController.itemPageSize,
|
|
focusedAttachmentId: focusedAttachmentId,
|
|
performInitialQuerySync: performInitialQuerySync
|
|
)
|
|
|
|
return DocumentTileViewController(
|
|
viewModel: viewModel
|
|
)
|
|
}
|
|
|
|
public static func createAllMediaViewController(
|
|
threadId: String,
|
|
threadVariant: SessionThread.Variant,
|
|
focusedAttachmentId: String?,
|
|
performInitialQuerySync: Bool = false
|
|
) -> AllMediaViewController {
|
|
let mediaTitleViewController = createMediaTileViewController(
|
|
threadId: threadId,
|
|
threadVariant: threadVariant,
|
|
focusedAttachmentId: focusedAttachmentId,
|
|
performInitialQuerySync: performInitialQuerySync
|
|
)
|
|
|
|
let documentTitleViewController = createDocumentTitleViewController(
|
|
threadId: threadId,
|
|
threadVariant: threadVariant,
|
|
focusedAttachmentId: focusedAttachmentId,
|
|
performInitialQuerySync: performInitialQuerySync
|
|
)
|
|
|
|
return AllMediaViewController(
|
|
mediaTitleViewController: mediaTitleViewController,
|
|
documentTitleViewController: documentTitleViewController
|
|
)
|
|
}
|
|
}
|