mirror of
https://github.com/Novaloop-AG/element-x-ios.git
synced 2026-10-31 16:24:11 +00:00
Stefan Ceriu
750 lines
34 KiB
Swift
750 lines
34 KiB
Swift
//
|
|
// Copyright 2026 Element Creations Ltd.
|
|
//
|
|
// SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
|
|
// Please see LICENSE files in the repository root for full details.
|
|
//
|
|
|
|
import Combine
|
|
import Compound
|
|
import GameController
|
|
import SwiftUI
|
|
import SwiftUIIntrospect
|
|
|
|
struct SearchScreen: View {
|
|
@Bindable var context: SearchScreenViewModel.Context
|
|
|
|
@FocusState private var isSearchFieldFocused: Bool
|
|
/// The result highlighted for hardware keyboard selection (arrow keys + return). Holds the id of a
|
|
/// room or a message depending on the active tab.
|
|
@State private var selectedID: String?
|
|
/// The selection is only meaningful with a hardware keyboard, so don't highlight anything otherwise.
|
|
@State private var isHardwareKeyboardConnected = false
|
|
|
|
/// The ids of the rows the user can select, in display order. These are the breadcrumbs
|
|
/// until a query is entered, after which they're the active tab's results.
|
|
private var selectableIDs: [String] {
|
|
guard context.viewState.isSearching else {
|
|
return context.viewState.breadcrumbs.map(\.id)
|
|
}
|
|
|
|
return switch context.viewState.bindings.searchMode {
|
|
case .rooms: context.viewState.rooms.map(\.id)
|
|
case .messages: context.viewState.messages.map(\.id)
|
|
}
|
|
}
|
|
|
|
var body: some View {
|
|
VStack(alignment: .leading, spacing: 0) {
|
|
// Rendered as content rather than a navigation title so it stays visible while the search field is focused.
|
|
Text(L10n.actionSearch)
|
|
.font(.compound.headingLGBold)
|
|
.foregroundStyle(.compound.textPrimary)
|
|
.accessibilityAddTraits(.isHeader)
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.padding(.horizontal, 16)
|
|
.padding(.vertical, 8)
|
|
|
|
// There's nothing to switch between until the user searches for something.
|
|
if context.viewState.isSearching {
|
|
Picker(L10n.actionSearch, selection: $context.searchMode) {
|
|
ForEach(SearchScreenMode.allCases) { mode in
|
|
Text(mode.title).tag(mode)
|
|
}
|
|
}
|
|
.pickerStyle(.segmented)
|
|
.padding(.horizontal, 16)
|
|
.padding(.bottom, 8)
|
|
}
|
|
|
|
switch context.viewState.bindings.searchMode {
|
|
case .rooms:
|
|
if context.viewState.rooms.isEmpty {
|
|
if context.viewState.isLoadingRooms {
|
|
loadingState
|
|
} else {
|
|
emptyState
|
|
}
|
|
} else {
|
|
roomList
|
|
}
|
|
case .messages:
|
|
if context.viewState.messages.isEmpty {
|
|
if context.viewState.isLoadingMessages {
|
|
loadingState
|
|
} else {
|
|
emptyState
|
|
}
|
|
} else {
|
|
messagesList
|
|
}
|
|
}
|
|
|
|
// Dismissing the search field (the tab bar's close button) leaves the tab.
|
|
SearchDismissalObserver { context.send(viewAction: .cancel) }
|
|
}
|
|
.frame(maxHeight: .infinity, alignment: .top)
|
|
.background(Color.compound.bgCanvasDefault)
|
|
.conditionalSearchable(searchQuery: $context.searchQuery)
|
|
.searchFocused($isSearchFieldFocused)
|
|
.autocorrectionDisabled(true)
|
|
.scrollDismissesKeyboard(.immediately)
|
|
.background(tabShortcuts)
|
|
.onSubmit(of: .search) {
|
|
// A software keyboard's submit/search button just dismisses; only a hardware return selects.
|
|
if isHardwareKeyboardConnected, selectedID != nil {
|
|
selectCurrent()
|
|
} else {
|
|
isSearchFieldFocused = false
|
|
}
|
|
}
|
|
.searchResultsKeyboardNavigation(moveUp: { moveSelection(backwards: true) },
|
|
moveDown: { moveSelection(backwards: false) },
|
|
cancel: { context.send(viewAction: .cancel) })
|
|
// The TabView calls onAppear/onDisappear each time the search tab is selected/deselected,
|
|
// so the field re-focuses, the query is cleared and the selection resets on every switch.
|
|
.onAppear {
|
|
context.send(viewAction: .appeared)
|
|
isSearchFieldFocused = true
|
|
selectedID = selectableIDs.first
|
|
updateHardwareKeyboardConnected()
|
|
}
|
|
.onDisappear {
|
|
// Previews and snapshot tests mount and unmount the view, don't clear their fixed state.
|
|
guard !ProcessInfo.isXcodePreview, !ProcessInfo.isRunningTests else { return }
|
|
context.searchQuery = ""
|
|
}
|
|
.onReceive(NotificationCenter.default.publisher(for: .GCKeyboardDidConnect)) { _ in
|
|
updateHardwareKeyboardConnected()
|
|
}
|
|
.onReceive(NotificationCenter.default.publisher(for: .GCKeyboardDidDisconnect)) { _ in
|
|
updateHardwareKeyboardConnected()
|
|
}
|
|
// Reset to the first result when the results change (e.g. a new query), keyed on the top result
|
|
// so pagination and background updates that leave it untouched don't clobber the selection.
|
|
.onChange(of: selectableIDs.first) {
|
|
selectedID = selectableIDs.first
|
|
}
|
|
// Reset the selection to the top when switching tabs.
|
|
.onChange(of: context.viewState.bindings.searchMode) {
|
|
selectedID = selectableIDs.first
|
|
}
|
|
}
|
|
|
|
@ViewBuilder
|
|
private var emptyState: some View {
|
|
if context.viewState.isSearching {
|
|
TitleAndIcon(title: L10n.commonNoResults,
|
|
subtitle: UntranslatedL10n.screenSearchNoResultsMessage(context.searchQuery),
|
|
icon: \.search,
|
|
iconStyle: .defaultSolid)
|
|
.frame(maxWidth: .infinity)
|
|
.padding(40)
|
|
} else if !context.viewState.breadcrumbs.isEmpty {
|
|
breadcrumbsList
|
|
} else {
|
|
TitleAndIcon(title: UntranslatedL10n.screenSearchEmptyStateTitle,
|
|
subtitle: UntranslatedL10n.screenSearchEmptyStateMessage,
|
|
icon: \.search,
|
|
iconStyle: .defaultSolid)
|
|
.frame(maxWidth: .infinity)
|
|
.padding(40)
|
|
}
|
|
}
|
|
|
|
private var loadingState: some View {
|
|
ProgressView()
|
|
.frame(maxWidth: .infinity)
|
|
.padding(40)
|
|
}
|
|
|
|
private var roomList: some View {
|
|
List {
|
|
ForEach(context.viewState.rooms) { room in
|
|
SearchScreenRoomCell(room: room,
|
|
context: context,
|
|
isSelected: isHardwareKeyboardConnected && selectedID == room.id)
|
|
.onAppear {
|
|
if room == context.viewState.rooms.first {
|
|
context.send(viewAction: .reachedTop)
|
|
} else if room == context.viewState.rooms.last {
|
|
context.send(viewAction: .reachedBottom)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
.compoundList(.plain)
|
|
}
|
|
|
|
private var messagesList: some View {
|
|
List {
|
|
ForEach(context.viewState.messages) { message in
|
|
SearchScreenMessageCell(message: message,
|
|
context: context,
|
|
isSelected: isHardwareKeyboardConnected && selectedID == message.id)
|
|
.onAppear {
|
|
if message == context.viewState.messages.last {
|
|
context.send(viewAction: .reachedBottom)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
.compoundList(.plain)
|
|
}
|
|
|
|
private var breadcrumbsList: some View {
|
|
List {
|
|
Section {
|
|
ForEach(context.viewState.breadcrumbs) { breadcrumb in
|
|
let isSelected = isHardwareKeyboardConnected && selectedID == breadcrumb.id
|
|
|
|
switch breadcrumb {
|
|
case .query(let query):
|
|
SearchScreenQueryCell(query: query, isSelected: isSelected) { context.searchQuery = query }
|
|
case .room(let room):
|
|
SearchScreenRoomCell(room: room, context: context, isSelected: isSelected, avatarSize: .searchHistory)
|
|
}
|
|
}
|
|
} header: {
|
|
Text(UntranslatedL10n.screenSearchRecentSearches)
|
|
.compoundListSectionHeader()
|
|
}
|
|
}
|
|
.compoundList(.plain)
|
|
}
|
|
|
|
/// Hidden buttons that switch tabs via ⌘1/⌘2, the common shortcut for jumping to tab N.
|
|
private var tabShortcuts: some View {
|
|
ForEach(Array(SearchScreenMode.allCases.enumerated()), id: \.element) { index, mode in
|
|
Button("") { context.searchMode = mode }
|
|
.keyboardShortcut(KeyEquivalent(Character("\(index + 1)")), modifiers: .command)
|
|
.hidden()
|
|
}
|
|
}
|
|
|
|
private func moveSelection(backwards: Bool) {
|
|
let ids = selectableIDs
|
|
guard let selectedID,
|
|
let currentIndex = ids.firstIndex(of: selectedID)
|
|
else {
|
|
selectedID = ids.first
|
|
return
|
|
}
|
|
|
|
let nextIndex = backwards ? currentIndex - 1 : currentIndex + 1
|
|
guard ids.indices.contains(nextIndex) else { return }
|
|
self.selectedID = ids[nextIndex]
|
|
}
|
|
|
|
private func selectCurrent() {
|
|
guard let selectedID else { return }
|
|
|
|
guard context.viewState.isSearching else {
|
|
let breadcrumb = context.viewState.breadcrumbs.first { $0.id == selectedID }
|
|
switch breadcrumb {
|
|
case .query(let query):
|
|
context.searchQuery = query
|
|
case .room(let room):
|
|
context.send(viewAction: .selectRoom(roomID: room.id))
|
|
case nil:
|
|
break
|
|
}
|
|
return
|
|
}
|
|
|
|
switch context.viewState.bindings.searchMode {
|
|
case .rooms:
|
|
context.send(viewAction: .selectRoom(roomID: selectedID))
|
|
case .messages:
|
|
guard let message = context.viewState.messages.first(where: { $0.id == selectedID }) else { return }
|
|
context.send(viewAction: .selectMessage(roomID: message.roomID, eventID: message.id))
|
|
}
|
|
}
|
|
|
|
private func updateHardwareKeyboardConnected() {
|
|
isHardwareKeyboardConnected = GCKeyboard.coalesced != nil
|
|
}
|
|
}
|
|
|
|
private extension View {
|
|
/// Searchable makes the preview contents randomly appear lower
|
|
@ViewBuilder func conditionalSearchable(searchQuery: Binding<String>) -> some View {
|
|
if !ProcessInfo.isXcodePreview, !ProcessInfo.isRunningTests {
|
|
searchable(text: searchQuery, placement: .toolbarPrincipal)
|
|
} else {
|
|
self
|
|
}
|
|
}
|
|
}
|
|
|
|
private struct SearchScreenRoomCell: View {
|
|
let room: SearchScreenRoom
|
|
let context: SearchScreenViewModel.Context
|
|
let isSelected: Bool
|
|
var avatarSize: RoomAvatarSizeOnScreen = .search
|
|
|
|
@Environment(\.dynamicTypeSize) private var dynamicTypeSize
|
|
|
|
var body: some View {
|
|
Button {
|
|
context.send(viewAction: .selectRoom(roomID: room.id))
|
|
} label: {
|
|
HStack(spacing: 16) {
|
|
avatar
|
|
|
|
VStack(alignment: .leading, spacing: 2) {
|
|
Text(room.title)
|
|
.font(.compound.bodyLGSemibold)
|
|
.foregroundStyle(.compound.textPrimary)
|
|
.lineLimit(1)
|
|
|
|
if !room.description.isEmpty {
|
|
Text(room.description)
|
|
.font(.compound.bodyMD)
|
|
.foregroundStyle(.compound.textSecondary)
|
|
.lineLimit(1)
|
|
}
|
|
}
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
}
|
|
.padding(.horizontal, 16)
|
|
.padding(.vertical, 12)
|
|
}
|
|
.buttonStyle(SearchScreenRoomCellButtonStyle(isSelected: isSelected))
|
|
.listRowInsets(.init())
|
|
.listRowSeparator(.hidden)
|
|
.rowDivider()
|
|
}
|
|
|
|
@ViewBuilder
|
|
private var avatar: some View {
|
|
if dynamicTypeSize < .accessibility3 {
|
|
RoomAvatarImage(avatar: room.avatar,
|
|
avatarSize: .room(on: avatarSize),
|
|
mediaProvider: context.mediaProvider)
|
|
.dynamicTypeSize(dynamicTypeSize < .accessibility1 ? dynamicTypeSize : .accessibility1)
|
|
.accessibilityHidden(true)
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Reports the search field being dismissed, which `isSearching` only exposes to the searchable view's children.
|
|
private struct SearchDismissalObserver: View {
|
|
@Environment(\.isSearching) private var isSearching
|
|
|
|
let action: () -> Void
|
|
|
|
var body: some View {
|
|
Color.clear
|
|
.frame(width: 0, height: 0)
|
|
.onChange(of: isSearching) { _, isSearching in
|
|
if !isSearching {
|
|
action()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private struct SearchScreenRoomCellButtonStyle: ButtonStyle {
|
|
let isSelected: Bool
|
|
|
|
func makeBody(configuration: Configuration) -> some View {
|
|
configuration.label
|
|
.background(isSelected || configuration.isPressed ? Color.compound.bgSubtleSecondary : Color.compound.bgCanvasDefault)
|
|
.contentShape(Rectangle())
|
|
.animation(isSelected ? .none : .easeOut(duration: 0.1).disabledDuringTests(), value: isSelected)
|
|
}
|
|
}
|
|
|
|
private struct SearchScreenQueryCell: View {
|
|
let query: String
|
|
let isSelected: Bool
|
|
let action: () -> Void
|
|
|
|
var body: some View {
|
|
Button(action: action) {
|
|
HStack(spacing: 16) {
|
|
CompoundIcon(\.history, size: .small, relativeTo: .compound.bodyLG)
|
|
.foregroundStyle(.compound.iconPrimary)
|
|
.scaledFrame(width: 32, height: 32)
|
|
.background(.compound.bgSubtleSecondary, in: RoundedRectangle(cornerRadius: 8, style: .continuous))
|
|
.accessibilityHidden(true)
|
|
|
|
ZStack(alignment: .leading) {
|
|
// Hidden text with 2 lines to match the height of the room rows, scaling with dynamic text.
|
|
Text(verbatim: " \n ")
|
|
.font(.compound.bodyLG)
|
|
|
|
Text(query)
|
|
.font(.compound.bodyLG)
|
|
.foregroundStyle(.compound.textPrimary)
|
|
.lineLimit(1)
|
|
}
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
}
|
|
.padding(.horizontal, 16)
|
|
.padding(.vertical, 12)
|
|
}
|
|
.buttonStyle(SearchScreenRoomCellButtonStyle(isSelected: isSelected))
|
|
.listRowInsets(.init())
|
|
.listRowSeparator(.hidden)
|
|
.rowDivider()
|
|
}
|
|
}
|
|
|
|
private struct SearchScreenMessageCell: View {
|
|
let message: SearchScreenMessage
|
|
let context: SearchScreenViewModel.Context
|
|
let isSelected: Bool
|
|
|
|
@Environment(\.dynamicTypeSize) private var dynamicTypeSize
|
|
|
|
var body: some View {
|
|
Button {
|
|
context.send(viewAction: .selectMessage(roomID: message.roomID, eventID: message.id))
|
|
} label: {
|
|
HStack(alignment: .top, spacing: 16) {
|
|
avatar
|
|
|
|
VStack(alignment: .leading, spacing: 4) {
|
|
HStack(alignment: .firstTextBaseline, spacing: 8) {
|
|
Text(message.roomName)
|
|
.font(.compound.bodyLGSemibold)
|
|
.foregroundStyle(.compound.textPrimary)
|
|
.lineLimit(3)
|
|
|
|
Spacer()
|
|
|
|
Text(message.timestamp.formattedMinimal())
|
|
.font(.compound.bodySM)
|
|
.foregroundStyle(.compound.textSecondary)
|
|
}
|
|
|
|
if let mediaPreview = message.mediaPreview {
|
|
SearchScreenMediaPreviewView(preview: mediaPreview, mediaProvider: context.mediaProvider)
|
|
} else if let preview = message.preview {
|
|
Text(preview)
|
|
.font(.compound.bodyMD)
|
|
.foregroundStyle(.compound.textSecondary)
|
|
.lineLimit(2)
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
}
|
|
}
|
|
}
|
|
.padding(.horizontal, 16)
|
|
.padding(.vertical, 12)
|
|
}
|
|
.buttonStyle(SearchScreenRoomCellButtonStyle(isSelected: isSelected))
|
|
.listRowInsets(.init())
|
|
.listRowSeparator(.hidden)
|
|
.rowDivider()
|
|
}
|
|
|
|
@ViewBuilder
|
|
private var avatar: some View {
|
|
if dynamicTypeSize < .accessibility3 {
|
|
RoomAvatarImage(avatar: message.roomAvatar,
|
|
avatarSize: .room(on: .search),
|
|
mediaProvider: context.mediaProvider)
|
|
.dynamicTypeSize(dynamicTypeSize < .accessibility1 ? dynamicTypeSize : .accessibility1)
|
|
.accessibilityHidden(true)
|
|
}
|
|
}
|
|
}
|
|
|
|
private struct SearchScreenMediaPreviewView: View {
|
|
let preview: SearchScreenMediaPreview
|
|
let mediaProvider: MediaProviderProtocol?
|
|
|
|
var body: some View {
|
|
HStack(spacing: 8) {
|
|
media
|
|
.scaledFrame(width: 36, height: 36)
|
|
|
|
VStack(alignment: .leading, spacing: 0) {
|
|
Text(preview.title)
|
|
.font(.compound.bodyLG)
|
|
.foregroundStyle(.compound.textPrimary)
|
|
.lineLimit(1)
|
|
Text(preview.details)
|
|
.font(.compound.bodySM)
|
|
.foregroundStyle(.compound.textSecondary)
|
|
.lineLimit(1)
|
|
}
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
}
|
|
.padding(.horizontal, 12)
|
|
.padding(.vertical, 8)
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.background(.compound.bgSubtleSecondary, in: RoundedRectangle(cornerRadius: 12))
|
|
}
|
|
|
|
@ViewBuilder
|
|
private var media: some View {
|
|
switch preview.kind {
|
|
case .file:
|
|
icon(\.attachment)
|
|
case .audio:
|
|
icon(\.audio)
|
|
case .image(let thumbnail, let blurhash):
|
|
thumbnailView(thumbnail, blurhash: blurhash, isVideo: false)
|
|
case .video(let thumbnail, let blurhash):
|
|
thumbnailView(thumbnail, blurhash: blurhash, isVideo: true)
|
|
}
|
|
}
|
|
|
|
private func icon(_ icon: KeyPath<CompoundIcons, Image>) -> some View {
|
|
CompoundIcon(icon)
|
|
.foregroundStyle(.compound.iconPrimary)
|
|
.scaledFrame(width: 36, height: 36)
|
|
.background(.compound.iconOnSolidPrimary,
|
|
in: RoundedRectangle(cornerRadius: 4, style: .continuous))
|
|
}
|
|
|
|
private func thumbnailView(_ thumbnail: ImageInfoProxy?, blurhash: String?, isVideo: Bool) -> some View {
|
|
Color.compound.bgSubtlePrimary // Let the image aspect fill in place
|
|
.overlay {
|
|
if let thumbnail {
|
|
LoadableImage(mediaSource: thumbnail.source,
|
|
blurhash: blurhash,
|
|
size: thumbnail.size,
|
|
mediaProvider: mediaProvider) {
|
|
Color.compound.bgSubtlePrimary
|
|
}
|
|
.mediaGalleryTimelineAspectRatio(imageInfo: thumbnail)
|
|
}
|
|
}
|
|
.overlay {
|
|
if isVideo {
|
|
CompoundIcon(\.playSolid, size: .small, relativeTo: .body)
|
|
.foregroundStyle(.compound.iconOnSolidPrimary)
|
|
}
|
|
}
|
|
.clipShape(RoundedRectangle(cornerRadius: 4, style: .continuous))
|
|
}
|
|
}
|
|
|
|
private extension View {
|
|
/// Forwards hardware up/down arrow and escape presses from the system search field to the given closures.
|
|
///
|
|
/// The `.search` role tab owns its text field, so there's no SwiftUI hook for its key presses. We reach the
|
|
/// field through the navigation stack (as ``SearchFieldStyle`` does) and swap its class for one that overrides
|
|
/// `pressesBegan` — the same key interception the old global search performed on its own field.
|
|
func searchResultsKeyboardNavigation(moveUp: @escaping () -> Void, moveDown: @escaping () -> Void, cancel: @escaping () -> Void) -> some View {
|
|
introspect(.navigationStack, on: .supportedVersions, scope: .ancestor) { navigationController in
|
|
guard let textField = navigationController.navigationBar.topItem?.searchController?.searchBar.searchTextField else {
|
|
return
|
|
}
|
|
|
|
if !(textField is KeyNavigatingSearchTextField) {
|
|
object_setClass(textField, KeyNavigatingSearchTextField.self)
|
|
}
|
|
|
|
KeyNavigatingSearchTextField.keyHandler = { keyCode in
|
|
switch keyCode {
|
|
case .keyboardUpArrow:
|
|
moveUp()
|
|
case .keyboardDownArrow:
|
|
moveDown()
|
|
case .keyboardEscape:
|
|
cancel()
|
|
default:
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// A `UISearchTextField` whose class is installed at runtime via `object_setClass`, so it must not declare any
|
|
/// stored properties. The handler is static, which is fine as there's only ever a single search field.
|
|
private final class KeyNavigatingSearchTextField: UISearchTextField {
|
|
static var keyHandler: ((UIKeyboardHIDUsage) -> Bool)?
|
|
|
|
override func pressesBegan(_ presses: Set<UIPress>, with event: UIPressesEvent?) {
|
|
if let keyCode = presses.first?.key?.keyCode, Self.keyHandler?(keyCode) == true {
|
|
return
|
|
}
|
|
super.pressesBegan(presses, with: event)
|
|
}
|
|
}
|
|
|
|
// MARK: - Previews
|
|
|
|
struct SearchScreen_Previews: PreviewProvider, TestablePreview {
|
|
static let emptyViewModel = SearchScreenViewModel(roomSummaryProvider: RoomSummaryProviderMock(.init(state: .loaded([]))),
|
|
clientProxy: makeClientProxy(),
|
|
mediaProvider: MediaProviderMock(.init()),
|
|
userIndicatorController: UserIndicatorControllerMock(),
|
|
appSettings: AppSettings.volatile())
|
|
static let noResultsViewModel = SearchScreenViewModel(roomSummaryProvider: RoomSummaryProviderMock(.init(state: .loaded([]))),
|
|
clientProxy: makeClientProxy(),
|
|
mediaProvider: MediaProviderMock(.init()),
|
|
userIndicatorController: UserIndicatorControllerMock(),
|
|
appSettings: AppSettings.volatile(),
|
|
initialSearchQuery: "John Doe")
|
|
static let roomsViewModel = SearchScreenViewModel(roomSummaryProvider: RoomSummaryProviderMock(.init(state: .loaded(.mockRooms))),
|
|
clientProxy: makeClientProxy(),
|
|
mediaProvider: MediaProviderMock(.init()),
|
|
userIndicatorController: UserIndicatorControllerMock(),
|
|
appSettings: AppSettings.volatile(),
|
|
initialSearchQuery: "Foundation")
|
|
static let messagesViewModel = SearchScreenViewModel(roomSummaryProvider: RoomSummaryProviderMock(.init(state: .loaded([]))),
|
|
clientProxy: makeClientProxy(searchService: makeSearchService(results: .mockResults)),
|
|
mediaProvider: MediaProviderMock(.init()),
|
|
userIndicatorController: UserIndicatorControllerMock(),
|
|
appSettings: AppSettings.volatile(),
|
|
initialSearchQuery: "Foundation",
|
|
initialSearchMode: .messages)
|
|
static let loadingMessagesViewModel = SearchScreenViewModel(roomSummaryProvider: RoomSummaryProviderMock(.init(state: .loaded([]))),
|
|
clientProxy: makeClientProxy(searchService: makeSearchService(paginationState: .loading)),
|
|
mediaProvider: MediaProviderMock(.init()),
|
|
userIndicatorController: UserIndicatorControllerMock(),
|
|
appSettings: AppSettings.volatile(),
|
|
initialSearchQuery: "Foundation",
|
|
initialSearchMode: .messages)
|
|
|
|
static let breadcrumbsViewModel = SearchScreenViewModel(roomSummaryProvider: RoomSummaryProviderMock(.init(state: .loaded([]))),
|
|
clientProxy: makeClientProxy(),
|
|
mediaProvider: MediaProviderMock(.init()),
|
|
userIndicatorController: UserIndicatorControllerMock(),
|
|
appSettings: makeAppSettings(breadcrumbs: [.room(roomID: "!room1:matrix.org"),
|
|
.query("Bob"),
|
|
.room(roomID: "!room5:matrix.org"),
|
|
.query("Element HR"),
|
|
.query("Alice")]))
|
|
|
|
static var previews: some View {
|
|
ElementNavigationStack {
|
|
SearchScreen(context: emptyViewModel.context)
|
|
}
|
|
.previewDisplayName("Empty")
|
|
|
|
ElementNavigationStack {
|
|
SearchScreen(context: breadcrumbsViewModel.context)
|
|
}
|
|
.previewDisplayName("Recent searches")
|
|
|
|
ElementNavigationStack {
|
|
SearchScreen(context: noResultsViewModel.context)
|
|
}
|
|
.previewDisplayName("No results")
|
|
|
|
ElementNavigationStack {
|
|
SearchScreen(context: roomsViewModel.context)
|
|
}
|
|
.previewDisplayName("Rooms")
|
|
|
|
ElementNavigationStack {
|
|
SearchScreen(context: messagesViewModel.context)
|
|
}
|
|
.previewDisplayName("Messages")
|
|
|
|
ElementNavigationStack {
|
|
SearchScreen(context: loadingMessagesViewModel.context)
|
|
}
|
|
.previewDisplayName("Loading messages")
|
|
}
|
|
|
|
private static func makeSearchService(results: [SearchServiceResult] = [], paginationState: SearchServicePaginationState = .idle(endReached: true)) -> SearchServiceProxyMock {
|
|
let mock = SearchServiceProxyMock()
|
|
mock.underlyingResultsPublisher = CurrentValueSubject<[SearchServiceResult], Never>(results).asCurrentValuePublisher()
|
|
mock.underlyingPaginationStatePublisher = CurrentValueSubject(paginationState).asCurrentValuePublisher()
|
|
mock.setQueryReturnValue = .success(())
|
|
return mock
|
|
}
|
|
|
|
private static func makeAppSettings(breadcrumbs: [SearchBreadcrumb]) -> AppSettings {
|
|
let appSettings = AppSettings.volatile()
|
|
appSettings.searchBreadcrumbs = breadcrumbs
|
|
return appSettings
|
|
}
|
|
|
|
private static func makeClientProxy(searchService: SearchServiceProxyMock = makeSearchService()) -> ClientProxyMock {
|
|
let mock = ClientProxyMock(.init(userID: "@alice:matrix.org"))
|
|
mock.searchService = searchService
|
|
let names: [String: String] = ["!room1:matrix.org": "Alice", "!room2:matrix.org": "Bob", "!room3:matrix.org": "Coline",
|
|
"!room4:matrix.org": "Bob", "!room5:matrix.org": "Office", "!room6:matrix.org": "Data analytics",
|
|
"!room7:matrix.org": "Alice", "!room8:matrix.org": "Bob", "!room9:matrix.org": "Coline"]
|
|
mock.roomSummaryForIdentifierClosure = { id in
|
|
let name = names[id] ?? id
|
|
return .mock(id: id, name: name, canonicalAlias: "#\(name.lowercased()):matrix.org")
|
|
}
|
|
return mock
|
|
}
|
|
}
|
|
|
|
private extension [SearchServiceResult] {
|
|
static var mockResults: [SearchServiceResult] {
|
|
[
|
|
SearchServiceResult(roomID: "!room1:matrix.org",
|
|
eventID: "$1",
|
|
sender: .init(id: "@alice:matrix.org", displayName: "Alice"),
|
|
content: .message(.text(.init(body: "Have you read the Foundation series?"))),
|
|
timestamp: .now),
|
|
SearchServiceResult(roomID: "!room2:matrix.org",
|
|
eventID: "$2",
|
|
sender: .init(id: "@bob:matrix.org", displayName: "Bob"),
|
|
content: .message(.text(.init(body: "The Second Foundation was hidden at the other end of the galaxy."))),
|
|
timestamp: .now),
|
|
SearchServiceResult(roomID: "!room3:matrix.org",
|
|
eventID: "$3",
|
|
sender: .init(id: "@coline:matrix.org", displayName: "Coline"),
|
|
content: .message(.file(.init(filename: "Foundation.pdf",
|
|
caption: nil,
|
|
source: nil,
|
|
fileSize: 4 * 1024 * 1024,
|
|
thumbnailSource: nil,
|
|
contentType: nil))),
|
|
timestamp: .now),
|
|
SearchServiceResult(roomID: "!room4:matrix.org",
|
|
eventID: "$4",
|
|
sender: .init(id: "@bob:matrix.org", displayName: "Bob"),
|
|
content: .message(.audio(.init(filename: "Foundation.mp3",
|
|
caption: nil,
|
|
duration: 42,
|
|
waveform: nil,
|
|
source: nil,
|
|
fileSize: 4 * 1024 * 1024,
|
|
contentType: nil))),
|
|
timestamp: .now),
|
|
SearchServiceResult(roomID: "!room5:matrix.org",
|
|
eventID: "$5",
|
|
sender: .init(id: "@office:matrix.org", displayName: "Office"),
|
|
content: .message(.image(.init(filename: "Foundation.jpg",
|
|
caption: nil,
|
|
imageInfo: .mockImage,
|
|
thumbnailInfo: .mockThumbnail,
|
|
blurhash: nil,
|
|
contentType: nil))),
|
|
timestamp: .now),
|
|
SearchServiceResult(roomID: "!room6:matrix.org",
|
|
eventID: "$6",
|
|
sender: .init(id: "@data:matrix.org", displayName: "Data analytics"),
|
|
content: .message(.video(.init(filename: "Foundation.mp4",
|
|
caption: nil,
|
|
videoInfo: .mockVideo,
|
|
thumbnailInfo: .mockThumbnail,
|
|
blurhash: nil,
|
|
contentType: nil))),
|
|
timestamp: .now),
|
|
SearchServiceResult(roomID: "!room7:matrix.org",
|
|
eventID: "$7",
|
|
sender: .init(id: "@alice:matrix.org", displayName: "Alice"),
|
|
content: .poll(question: "What's your favourite Foundation book?"),
|
|
timestamp: .now),
|
|
SearchServiceResult(roomID: "!room8:matrix.org",
|
|
eventID: "$8",
|
|
sender: .init(id: "@bob:matrix.org", displayName: "Bob"),
|
|
content: .liveLocation,
|
|
timestamp: .now),
|
|
SearchServiceResult(roomID: "!room9:matrix.org",
|
|
eventID: "$9",
|
|
sender: .init(id: "@coline:matrix.org", displayName: "Coline"),
|
|
content: .redacted,
|
|
timestamp: .now)
|
|
]
|
|
}
|
|
}
|