1059 lines
40 KiB
Swift
1059 lines
40 KiB
Swift
//
|
||
// Copyright 2017 Signal Messenger, LLC
|
||
// SPDX-License-Identifier: AGPL-3.0-only
|
||
//
|
||
|
||
import BonMot
|
||
import Foundation
|
||
import SignalServiceKit
|
||
import SignalMessaging
|
||
|
||
public typealias MessageSortKey = UInt64
|
||
|
||
public struct ConversationSortKey: Comparable {
|
||
let isContactThread: Bool
|
||
let creationDate: Date?
|
||
let lastInteractionRowId: UInt64
|
||
|
||
// MARK: Comparable
|
||
|
||
public static func < (lhs: ConversationSortKey, rhs: ConversationSortKey) -> Bool {
|
||
// always show matching contact results first
|
||
if lhs.isContactThread, !rhs.isContactThread {
|
||
return false
|
||
} else if !lhs.isContactThread, rhs.isContactThread {
|
||
return true
|
||
}
|
||
|
||
if lhs.lastInteractionRowId != rhs.lastInteractionRowId {
|
||
return lhs.lastInteractionRowId < rhs.lastInteractionRowId
|
||
}
|
||
let longAgo = Date(timeIntervalSince1970: 0)
|
||
let lhsDate = lhs.creationDate ?? longAgo
|
||
let rhsDate = rhs.creationDate ?? longAgo
|
||
return lhsDate < rhsDate
|
||
}
|
||
}
|
||
|
||
// MARK: -
|
||
|
||
public class ConversationSearchResult<SortKey>: Comparable where SortKey: Comparable {
|
||
public let thread: ThreadViewModel
|
||
|
||
public let messageId: String?
|
||
public let messageDate: Date?
|
||
|
||
public let snippet: CVTextValue?
|
||
|
||
private let sortKey: SortKey
|
||
|
||
init(thread: ThreadViewModel, sortKey: SortKey, messageId: String? = nil, messageDate: Date? = nil, snippet: CVTextValue? = nil) {
|
||
self.thread = thread
|
||
self.sortKey = sortKey
|
||
self.messageId = messageId
|
||
self.messageDate = messageDate
|
||
self.snippet = snippet
|
||
}
|
||
|
||
// MARK: Comparable
|
||
|
||
public static func < (lhs: ConversationSearchResult, rhs: ConversationSearchResult) -> Bool {
|
||
return lhs.sortKey < rhs.sortKey
|
||
}
|
||
|
||
// MARK: Equatable
|
||
|
||
public static func == (lhs: ConversationSearchResult, rhs: ConversationSearchResult) -> Bool {
|
||
return lhs.thread.threadRecord.uniqueId == rhs.thread.threadRecord.uniqueId &&
|
||
lhs.messageId == rhs.messageId
|
||
}
|
||
}
|
||
|
||
// MARK: -
|
||
|
||
public class ContactSearchResult: Comparable, Dependencies {
|
||
|
||
public let signalAccount: SignalAccount
|
||
private let comparableName: String
|
||
|
||
public var recipientAddress: SignalServiceAddress {
|
||
return signalAccount.recipientAddress
|
||
}
|
||
|
||
init(signalAccount: SignalAccount, transaction: SDSAnyReadTransaction) {
|
||
self.signalAccount = signalAccount
|
||
self.comparableName = Self.contactsManager.comparableName(for: signalAccount, transaction: transaction)
|
||
}
|
||
|
||
// MARK: Comparable
|
||
|
||
public static func < (lhs: ContactSearchResult, rhs: ContactSearchResult) -> Bool {
|
||
var comparisonResult = lhs.comparableName.caseInsensitiveCompare(rhs.comparableName)
|
||
|
||
if comparisonResult == .orderedSame {
|
||
comparisonResult = lhs.recipientAddress.stringForDisplay.compare(rhs.recipientAddress.stringForDisplay)
|
||
}
|
||
|
||
return comparisonResult == .orderedAscending
|
||
}
|
||
|
||
// MARK: Equatable
|
||
|
||
public static func == (lhs: ContactSearchResult, rhs: ContactSearchResult) -> Bool {
|
||
return lhs.recipientAddress == rhs.recipientAddress
|
||
}
|
||
}
|
||
|
||
// MARK: -
|
||
|
||
/// Can represent either a group thread with stories, or a private story thread.
|
||
public class StorySearchResult: Comparable {
|
||
|
||
public let thread: TSThread
|
||
|
||
private let sortKey: ConversationSortKey
|
||
|
||
init(thread: TSThread, sortKey: ConversationSortKey) {
|
||
self.thread = thread
|
||
self.sortKey = sortKey
|
||
}
|
||
|
||
// MARK: Comparable
|
||
|
||
public static func < (lhs: StorySearchResult, rhs: StorySearchResult) -> Bool {
|
||
return lhs.sortKey < rhs.sortKey
|
||
}
|
||
|
||
// MARK: Equatable
|
||
|
||
public static func == (lhs: StorySearchResult, rhs: StorySearchResult) -> Bool {
|
||
return lhs.thread.uniqueId == rhs.thread.uniqueId
|
||
}
|
||
}
|
||
|
||
// MARK: -
|
||
|
||
public class HomeScreenSearchResultSet: NSObject {
|
||
public let searchText: String
|
||
public let contactThreads: [ConversationSearchResult<ConversationSortKey>]
|
||
public let groupThreads: [GroupSearchResult]
|
||
public let contacts: [ContactSearchResult]
|
||
public let messages: [ConversationSearchResult<MessageSortKey>]
|
||
|
||
public init(
|
||
searchText: String,
|
||
contactThreads: [ConversationSearchResult<ConversationSortKey>],
|
||
groupThreads: [GroupSearchResult],
|
||
contacts: [ContactSearchResult],
|
||
messages: [ConversationSearchResult<MessageSortKey>]
|
||
) {
|
||
self.searchText = searchText
|
||
self.contactThreads = contactThreads
|
||
self.groupThreads = groupThreads
|
||
self.contacts = contacts
|
||
self.messages = messages
|
||
}
|
||
|
||
public class var empty: HomeScreenSearchResultSet {
|
||
return HomeScreenSearchResultSet(searchText: "", contactThreads: [], groupThreads: [], contacts: [], messages: [])
|
||
}
|
||
|
||
public var isEmpty: Bool {
|
||
return contactThreads.isEmpty && groupThreads.isEmpty && contacts.isEmpty && messages.isEmpty
|
||
}
|
||
}
|
||
|
||
// MARK: -
|
||
|
||
public class GroupSearchResult: Comparable {
|
||
|
||
public let thread: ThreadViewModel
|
||
public let matchedMembersSnippet: String?
|
||
|
||
private let sortKey: ConversationSortKey
|
||
|
||
class func withMatchedMembersSnippet(
|
||
thread: ThreadViewModel,
|
||
sortKey: ConversationSortKey,
|
||
searchText: String,
|
||
nameResolver: NameResolver,
|
||
transaction: SDSAnyReadTransaction
|
||
) -> GroupSearchResult? {
|
||
guard let groupThread = thread.threadRecord as? TSGroupThread else {
|
||
owsFailDebug("Unexpected thread type")
|
||
return nil
|
||
}
|
||
let matchedMembers = groupThread.sortedMemberNames(
|
||
searchText: searchText,
|
||
includingBlocked: true,
|
||
nameResolver: nameResolver,
|
||
transaction: transaction
|
||
)
|
||
let matchedMembersSnippet = matchedMembers.joined(separator: ", ")
|
||
return GroupSearchResult(thread: thread, sortKey: sortKey, matchedMembersSnippet: matchedMembersSnippet)
|
||
}
|
||
|
||
init(thread: ThreadViewModel, sortKey: ConversationSortKey, matchedMembersSnippet: String? = nil) {
|
||
self.thread = thread
|
||
self.sortKey = sortKey
|
||
self.matchedMembersSnippet = matchedMembersSnippet
|
||
}
|
||
|
||
// MARK: Comparable
|
||
|
||
public static func < (lhs: GroupSearchResult, rhs: GroupSearchResult) -> Bool {
|
||
return lhs.sortKey < rhs.sortKey
|
||
}
|
||
|
||
// MARK: Equatable
|
||
|
||
public static func == (lhs: GroupSearchResult, rhs: GroupSearchResult) -> Bool {
|
||
return lhs.thread.threadRecord.uniqueId == rhs.thread.threadRecord.uniqueId
|
||
}
|
||
}
|
||
|
||
// MARK: -
|
||
|
||
public class ComposeScreenSearchResultSet: Equatable {
|
||
|
||
public let searchText: String
|
||
|
||
public let groups: [GroupSearchResult]
|
||
|
||
public var groupThreads: [TSGroupThread] {
|
||
return groups.compactMap { $0.thread.threadRecord as? TSGroupThread }
|
||
}
|
||
|
||
public let signalContacts: [ContactSearchResult]
|
||
|
||
public var signalAccounts: [SignalAccount] {
|
||
return signalContacts.map { $0.signalAccount }
|
||
}
|
||
|
||
public init(searchText: String, groups: [GroupSearchResult], signalContacts: [ContactSearchResult]) {
|
||
self.searchText = searchText
|
||
self.groups = groups
|
||
self.signalContacts = signalContacts
|
||
}
|
||
|
||
public static let empty = ComposeScreenSearchResultSet(searchText: "", groups: [], signalContacts: [])
|
||
|
||
public var isEmpty: Bool {
|
||
return groups.isEmpty && signalContacts.isEmpty
|
||
}
|
||
|
||
public var logDescription: String {
|
||
var sections = [String]()
|
||
if !groups.isEmpty {
|
||
var splits = [String]()
|
||
for group in groups {
|
||
splits.append(group.thread.threadRecord.uniqueId)
|
||
}
|
||
sections.append("groups: " + splits.joined(separator: ","))
|
||
}
|
||
if !signalAccounts.isEmpty {
|
||
var splits = [String]()
|
||
for signalAccount in signalAccounts {
|
||
splits.append(signalAccount.addressComponentsDescription)
|
||
}
|
||
sections.append("signalAccounts: " + splits.joined(separator: ","))
|
||
}
|
||
return "[" + sections.joined(separator: ",") + "]"
|
||
}
|
||
|
||
public static func == (lhs: ComposeScreenSearchResultSet, rhs: ComposeScreenSearchResultSet) -> Bool {
|
||
guard lhs.searchText == rhs.searchText else { return false }
|
||
guard lhs.groups == rhs.groups else { return false }
|
||
guard lhs.signalAccounts == rhs.signalAccounts else { return false }
|
||
return true
|
||
}
|
||
}
|
||
|
||
// MARK: -
|
||
|
||
public class ConversationPickerScreenSearchResultSet: NSObject {
|
||
|
||
public let searchText: String
|
||
|
||
public let groups: [GroupSearchResult]
|
||
|
||
public var groupThreads: [TSGroupThread] {
|
||
return groups.compactMap { $0.thread.threadRecord as? TSGroupThread }
|
||
}
|
||
|
||
public let signalContacts: [ContactSearchResult]
|
||
|
||
public var signalAccounts: [SignalAccount] {
|
||
return signalContacts.map { $0.signalAccount }
|
||
}
|
||
|
||
/// Includes both group threads with stories, and private story threads.
|
||
public let storyResults: [StorySearchResult]
|
||
|
||
public var storyThreads: [TSThread] {
|
||
return storyResults.map(\.thread)
|
||
}
|
||
|
||
public init(
|
||
searchText: String,
|
||
groups: [GroupSearchResult],
|
||
storyThreads: [StorySearchResult],
|
||
signalContacts: [ContactSearchResult]
|
||
) {
|
||
self.searchText = searchText
|
||
self.groups = groups
|
||
self.storyResults = storyThreads
|
||
self.signalContacts = signalContacts
|
||
}
|
||
|
||
public static let empty = ComposeScreenSearchResultSet(searchText: "", groups: [], signalContacts: [])
|
||
|
||
public var isEmpty: Bool {
|
||
return groups.isEmpty && signalContacts.isEmpty
|
||
}
|
||
|
||
public var logDescription: String {
|
||
var sections = [String]()
|
||
if !groups.isEmpty {
|
||
var splits = [String]()
|
||
for group in groups {
|
||
splits.append(group.thread.threadRecord.uniqueId)
|
||
}
|
||
sections.append("groups: " + splits.joined(separator: ","))
|
||
}
|
||
if !signalAccounts.isEmpty {
|
||
var splits = [String]()
|
||
for signalAccount in signalAccounts {
|
||
splits.append(signalAccount.addressComponentsDescription)
|
||
}
|
||
sections.append("signalAccounts: " + splits.joined(separator: ","))
|
||
}
|
||
return "[" + sections.joined(separator: ",") + "]"
|
||
}
|
||
}
|
||
|
||
// MARK: -
|
||
|
||
public class MessageSearchResult: NSObject, Comparable {
|
||
|
||
public let messageId: String
|
||
public let sortId: UInt64
|
||
|
||
init(messageId: String, sortId: UInt64) {
|
||
self.messageId = messageId
|
||
self.sortId = sortId
|
||
}
|
||
|
||
// MARK: - Comparable
|
||
|
||
public static func < (lhs: MessageSearchResult, rhs: MessageSearchResult) -> Bool {
|
||
return lhs.sortId < rhs.sortId
|
||
}
|
||
}
|
||
|
||
// MARK: -
|
||
|
||
public class ConversationScreenSearchResultSet: NSObject {
|
||
|
||
public let searchText: String
|
||
|
||
public let messages: [MessageSearchResult]
|
||
|
||
public lazy var messageSortIds: [UInt64] = {
|
||
return messages.map { $0.sortId }
|
||
}()
|
||
|
||
// MARK: Static members
|
||
|
||
public static let empty: ConversationScreenSearchResultSet = ConversationScreenSearchResultSet(searchText: "", messages: [])
|
||
|
||
// MARK: Init
|
||
|
||
public init(searchText: String, messages: [MessageSearchResult]) {
|
||
self.searchText = searchText
|
||
self.messages = messages
|
||
}
|
||
|
||
// MARK: - CustomDebugStringConvertible
|
||
|
||
override public var debugDescription: String {
|
||
return "ConversationScreenSearchResultSet(searchText: \(searchText), messages: [\(messages.count) matches])"
|
||
}
|
||
}
|
||
|
||
public class FullTextSearcher: NSObject {
|
||
|
||
public static let kDefaultMaxResults: UInt = 500
|
||
|
||
public static let shared: FullTextSearcher = FullTextSearcher()
|
||
|
||
public func searchForComposeScreen(
|
||
searchText: String,
|
||
omitLocalUser: Bool,
|
||
maxResults: UInt = kDefaultMaxResults,
|
||
transaction: SDSAnyReadTransaction
|
||
) -> ComposeScreenSearchResultSet {
|
||
var signalContactMap = [SignalServiceAddress: ContactSearchResult]()
|
||
var signalRecipentResults: [ContactSearchResult] = []
|
||
var groups: [GroupSearchResult] = []
|
||
|
||
var hasReachedMaxResults: Bool {
|
||
guard (signalContactMap.count + signalRecipentResults.count + groups.count) < maxResults else { return true }
|
||
return false
|
||
}
|
||
|
||
FullTextSearchFinder.enumerateObjects(
|
||
searchText: searchText,
|
||
collections: [
|
||
SignalAccount.collection(),
|
||
SignalRecipient.collection(),
|
||
TSThread.collection()
|
||
],
|
||
maxResults: maxResults,
|
||
transaction: transaction
|
||
) { match, _, stop in
|
||
guard !hasReachedMaxResults else {
|
||
stop = true
|
||
return
|
||
}
|
||
|
||
switch match {
|
||
case let signalAccount as SignalAccount:
|
||
let searchResult = ContactSearchResult(signalAccount: signalAccount, transaction: transaction)
|
||
assert(signalContactMap[signalAccount.recipientAddress] == nil)
|
||
signalContactMap[signalAccount.recipientAddress] = searchResult
|
||
case let signalRecipient as SignalRecipient:
|
||
guard
|
||
signalRecipient.isRegistered,
|
||
!DependenciesBridge.shared.recipientHidingManager.isHiddenAddress(
|
||
signalRecipient.address,
|
||
tx: transaction.asV2Read
|
||
),
|
||
!blockingManager.isAddressBlocked(
|
||
signalRecipient.address,
|
||
transaction: transaction
|
||
)
|
||
else {
|
||
return
|
||
}
|
||
let signalAccount = SignalAccount.transientSignalAccount(forSignalRecipient: signalRecipient)
|
||
let searchResult = ContactSearchResult(signalAccount: signalAccount, transaction: transaction)
|
||
signalRecipentResults.append(searchResult)
|
||
case let groupThread as TSGroupThread:
|
||
let sortKey = ConversationSortKey(isContactThread: false,
|
||
creationDate: groupThread.creationDate,
|
||
lastInteractionRowId: groupThread.lastInteractionRowId)
|
||
let threadViewModel = ThreadViewModel(thread: groupThread,
|
||
forChatList: true,
|
||
transaction: transaction)
|
||
let searchResult = GroupSearchResult(thread: threadViewModel, sortKey: sortKey)
|
||
groups.append(searchResult)
|
||
case is TSContactThread:
|
||
// not included in compose screen results
|
||
break
|
||
case is TSPrivateStoryThread:
|
||
// not included in compose screen results
|
||
break
|
||
default:
|
||
owsFailDebug("Unexpected match of type \(type(of: match))")
|
||
}
|
||
}
|
||
|
||
// Fill in user matches from SignalRecipients, but only if
|
||
// we don't already have a SignalAccount for the same user.
|
||
for signalRecipentResult in signalRecipentResults {
|
||
if signalContactMap[signalRecipentResult.recipientAddress] == nil {
|
||
signalContactMap[signalRecipentResult.recipientAddress] = signalRecipentResult
|
||
}
|
||
}
|
||
|
||
if let localAddress = DependenciesBridge.shared.tsAccountManager.localIdentifiers(tx: transaction.asV2Read)?.aciAddress {
|
||
if matchesNoteToSelf(searchText: searchText, transaction: transaction) {
|
||
if signalContactMap[localAddress] == nil {
|
||
let localAccount = SignalAccount(address: localAddress)
|
||
let localResult = ContactSearchResult(signalAccount: localAccount, transaction: transaction)
|
||
signalContactMap[localAddress] = localResult
|
||
}
|
||
}
|
||
} else {
|
||
owsFailDebug("localAddress was unexpectedly nil")
|
||
}
|
||
|
||
// Filter out contact results with pending message requests.
|
||
var signalContacts = Array(signalContactMap.values).filter { (contactResult: ContactSearchResult) in
|
||
!self.shouldFilterContactResult(contactResult: contactResult,
|
||
omitLocalUser: omitLocalUser,
|
||
transaction: transaction)
|
||
}
|
||
// Order contact results by display name.
|
||
signalContacts.sort()
|
||
|
||
// Order the conversation and message results in reverse chronological order.
|
||
// The contact results are pre-sorted by display name.
|
||
groups.sort(by: >)
|
||
|
||
return ComposeScreenSearchResultSet(searchText: searchText, groups: groups, signalContacts: signalContacts)
|
||
}
|
||
|
||
public func searchForConversationPickerScreen(
|
||
searchText: String,
|
||
maxResults: UInt = kDefaultMaxResults,
|
||
transaction: SDSAnyReadTransaction
|
||
) -> ConversationPickerScreenSearchResultSet {
|
||
|
||
var signalContactMap = [SignalServiceAddress: ContactSearchResult]()
|
||
var signalRecipentResults: [ContactSearchResult] = []
|
||
var groups: [GroupSearchResult] = []
|
||
var storyThreads: [StorySearchResult] = []
|
||
|
||
var hasReachedMaxResults: Bool {
|
||
guard (signalContactMap.count + signalRecipentResults.count + groups.count + storyThreads.count) < maxResults else { return true }
|
||
return false
|
||
}
|
||
|
||
FullTextSearchFinder.enumerateObjects(
|
||
searchText: searchText,
|
||
collections: [
|
||
SignalAccount.collection(),
|
||
SignalRecipient.collection(),
|
||
TSThread.collection()
|
||
],
|
||
maxResults: maxResults,
|
||
transaction: transaction
|
||
) { match, _, stop in
|
||
guard !hasReachedMaxResults else {
|
||
stop = true
|
||
return
|
||
}
|
||
|
||
switch match {
|
||
case let signalAccount as SignalAccount:
|
||
let searchResult = ContactSearchResult(signalAccount: signalAccount, transaction: transaction)
|
||
assert(signalContactMap[signalAccount.recipientAddress] == nil)
|
||
signalContactMap[signalAccount.recipientAddress] = searchResult
|
||
case let signalRecipient as SignalRecipient:
|
||
guard signalRecipient.isRegistered else {
|
||
return
|
||
}
|
||
let signalAccount = SignalAccount.transientSignalAccount(forSignalRecipient: signalRecipient)
|
||
let searchResult = ContactSearchResult(signalAccount: signalAccount, transaction: transaction)
|
||
signalRecipentResults.append(searchResult)
|
||
case let groupThread as TSGroupThread:
|
||
let sortKey = ConversationSortKey(isContactThread: false,
|
||
creationDate: groupThread.creationDate,
|
||
lastInteractionRowId: groupThread.lastInteractionRowId)
|
||
let threadViewModel = ThreadViewModel(thread: groupThread,
|
||
forChatList: true,
|
||
transaction: transaction)
|
||
let searchResult = GroupSearchResult(thread: threadViewModel, sortKey: sortKey)
|
||
groups.append(searchResult)
|
||
|
||
if groupThread.isStorySendEnabled(transaction: transaction) {
|
||
let searchResult = StorySearchResult(thread: groupThread, sortKey: sortKey)
|
||
storyThreads.append(searchResult)
|
||
}
|
||
|
||
case let storyThread as TSPrivateStoryThread:
|
||
guard storyThread.storyViewMode != .disabled else {
|
||
// Don't show disabled private story threads; these are queued up
|
||
// to be deleted.
|
||
break
|
||
}
|
||
let sortKey = ConversationSortKey(
|
||
isContactThread: false,
|
||
creationDate: storyThread.creationDate,
|
||
lastInteractionRowId: storyThread.lastInteractionRowId
|
||
)
|
||
let searchResult = StorySearchResult(thread: storyThread, sortKey: sortKey)
|
||
storyThreads.append(searchResult)
|
||
case is TSContactThread:
|
||
// not included in compose screen results
|
||
break
|
||
default:
|
||
owsFailDebug("Unexpected match of type \(type(of: match))")
|
||
}
|
||
}
|
||
|
||
// Fill in user matches from SignalRecipients, but only if
|
||
// we don't already have a SignalAccount for the same user.
|
||
for signalRecipentResult in signalRecipentResults {
|
||
if signalContactMap[signalRecipentResult.recipientAddress] == nil {
|
||
signalContactMap[signalRecipentResult.recipientAddress] = signalRecipentResult
|
||
}
|
||
}
|
||
|
||
if let localAddress = DependenciesBridge.shared.tsAccountManager.localIdentifiers(tx: transaction.asV2Read)?.aciAddress {
|
||
if matchesNoteToSelf(searchText: searchText, transaction: transaction) {
|
||
if signalContactMap[localAddress] == nil {
|
||
let localAccount = SignalAccount(address: localAddress)
|
||
let localResult = ContactSearchResult(signalAccount: localAccount, transaction: transaction)
|
||
signalContactMap[localAddress] = localResult
|
||
}
|
||
}
|
||
} else {
|
||
owsFailDebug("localAddress was unexpectedly nil")
|
||
}
|
||
|
||
// Filter out contact results with pending message requests.
|
||
var signalContacts = Array(signalContactMap.values).filter { (contactResult: ContactSearchResult) in
|
||
!self.shouldFilterContactResult(contactResult: contactResult,
|
||
omitLocalUser: false,
|
||
transaction: transaction)
|
||
}
|
||
// Order contact results by display name.
|
||
signalContacts.sort()
|
||
|
||
// Order the conversation and message results in reverse chronological order.
|
||
// The contact results are pre-sorted by display name.
|
||
groups.sort(by: >)
|
||
|
||
return ConversationPickerScreenSearchResultSet(
|
||
searchText: searchText,
|
||
groups: groups,
|
||
storyThreads: storyThreads,
|
||
signalContacts: signalContacts
|
||
)
|
||
}
|
||
|
||
func shouldFilterContactResult(contactResult: ContactSearchResult,
|
||
omitLocalUser: Bool,
|
||
transaction: SDSAnyReadTransaction) -> Bool {
|
||
let address = contactResult.recipientAddress
|
||
if address.isLocalAddress {
|
||
return omitLocalUser
|
||
}
|
||
if self.contactsManager.isSystemContact(address: address, transaction: transaction) {
|
||
return false
|
||
}
|
||
guard let thread = TSContactThread.getWithContactAddress(address, transaction: transaction) else {
|
||
// Filter out users with whom we've never had contact.
|
||
return true
|
||
}
|
||
return thread.hasPendingMessageRequest(transaction: transaction)
|
||
}
|
||
|
||
func matchesNoteToSelf(searchText: String, transaction: SDSAnyReadTransaction) -> Bool {
|
||
guard let localAddress = DependenciesBridge.shared.tsAccountManager.localIdentifiers(tx: transaction.asV2Read)?.aciAddress else {
|
||
return false
|
||
}
|
||
let noteToSelfText = self.conversationIndexingString(address: localAddress, transaction: transaction)
|
||
let matchedTerm = searchText.split(separator: " ").first { term in
|
||
return noteToSelfText.contains(term)
|
||
}
|
||
|
||
return matchedTerm != nil
|
||
}
|
||
|
||
public func searchForHomeScreen(
|
||
searchText: String,
|
||
maxResults: UInt = kDefaultMaxResults,
|
||
isCanceled: () -> Bool,
|
||
transaction: SDSAnyReadTransaction
|
||
) -> HomeScreenSearchResultSet? {
|
||
var contactThreads: [ConversationSearchResult<ConversationSortKey>] = []
|
||
var groupThreads: [GroupSearchResult] = []
|
||
var groupThreadIds = Set<String>()
|
||
var contactsMap: [SignalServiceAddress: ContactSearchResult] = [:]
|
||
var messages: [UInt64: ConversationSearchResult<MessageSortKey>] = [:]
|
||
|
||
var existingConversationAddresses: Set<SignalServiceAddress> = Set()
|
||
|
||
let nameResolver = NameResolverImpl(contactsManager: contactsManager)
|
||
|
||
var threadCache = [String: TSThread]()
|
||
let getThread: (String) -> TSThread? = { threadUniqueId in
|
||
if let thread = threadCache[threadUniqueId] {
|
||
return thread
|
||
}
|
||
guard let thread = TSThread.anyFetch(uniqueId: threadUniqueId, transaction: transaction) else {
|
||
return nil
|
||
}
|
||
threadCache[threadUniqueId] = thread
|
||
return thread
|
||
}
|
||
|
||
var threadViewModelCache = [String: ThreadViewModel]()
|
||
let getThreadViewModel: (TSThread) -> ThreadViewModel = { thread in
|
||
if let threadViewModel = threadViewModelCache[thread.uniqueId] {
|
||
return threadViewModel
|
||
}
|
||
let threadViewModel = ThreadViewModel(thread: thread,
|
||
forChatList: true,
|
||
transaction: transaction)
|
||
threadViewModelCache[thread.uniqueId] = threadViewModel
|
||
return threadViewModel
|
||
}
|
||
|
||
let getMentionedMessages: (SignalServiceAddress) -> [TSMessage] = { address in
|
||
guard let aci = address.aci else { return [] }
|
||
return MentionFinder.messagesMentioning(aci: aci, tx: transaction)
|
||
}
|
||
|
||
func appendMessage(_ message: TSMessage, snippet: CVTextValue?) {
|
||
guard let thread = getThread(message.uniqueThreadId) else {
|
||
owsFailDebug("Missing thread: \(type(of: message))")
|
||
return
|
||
}
|
||
|
||
let threadViewModel = getThreadViewModel(thread)
|
||
let sortKey = message.sortId
|
||
let searchResult = ConversationSearchResult(
|
||
thread: threadViewModel,
|
||
sortKey: sortKey,
|
||
messageId: message.uniqueId,
|
||
messageDate: NSDate.ows_date(withMillisecondsSince1970: message.timestamp),
|
||
snippet: snippet
|
||
)
|
||
guard messages[sortKey] == nil else { return }
|
||
messages[sortKey] = searchResult
|
||
}
|
||
|
||
func appendSignalAccount(_ signalAccount: SignalAccount) {
|
||
guard contactsMap[signalAccount.recipientAddress] == nil else { return }
|
||
let searchResult = ContactSearchResult(signalAccount: signalAccount, transaction: transaction)
|
||
contactsMap[searchResult.recipientAddress] = searchResult
|
||
|
||
getMentionedMessages(signalAccount.recipientAddress)
|
||
.forEach { message in
|
||
appendMessage(message, snippet: .messageBody(message.conversationListPreviewText(transaction)))
|
||
}
|
||
}
|
||
|
||
var remainingAllowedResults: UInt {
|
||
UInt(max(0, Int(maxResults) - (contactThreads.count + groupThreads.count + contactsMap.count + messages.count)))
|
||
}
|
||
|
||
var hasReachedMaxResults: Bool {
|
||
guard remainingAllowedResults > 0 else { return true }
|
||
return false
|
||
}
|
||
|
||
// We search for each type of result independently. The order here matters
|
||
// – we want to give priority to chat and contact results above message
|
||
// results. This makes sure if I search for a string like "Matthew" the
|
||
// first results will be the chat with my contact named "Matthew", rather
|
||
// than messages where his name was mentioned.
|
||
|
||
// Check if we've been canceled before running the first query. If we have
|
||
// to wait a while for the database to be available, this search may have
|
||
// already been canceled.
|
||
guard !isCanceled() else {
|
||
return nil
|
||
}
|
||
|
||
FullTextSearchFinder.enumerateObjects(
|
||
searchText: searchText,
|
||
maxResults: remainingAllowedResults,
|
||
transaction: transaction
|
||
) { (thread: TSThread, _, stop) in
|
||
guard !isCanceled(), !hasReachedMaxResults else {
|
||
stop = true
|
||
return
|
||
}
|
||
|
||
// Ignore deleted threads.
|
||
guard thread.shouldThreadBeVisible else { return }
|
||
|
||
let threadViewModel = getThreadViewModel(thread)
|
||
let sortKey = ConversationSortKey(
|
||
isContactThread: thread is TSContactThread,
|
||
creationDate: thread.creationDate,
|
||
lastInteractionRowId: thread.lastInteractionRowId
|
||
)
|
||
|
||
switch thread {
|
||
case is TSGroupThread:
|
||
guard let searchResult = GroupSearchResult.withMatchedMembersSnippet(
|
||
thread: threadViewModel,
|
||
sortKey: sortKey,
|
||
searchText: searchText,
|
||
nameResolver: nameResolver,
|
||
transaction: transaction
|
||
) else {
|
||
return owsFailDebug("Unexpectedly failed to determine members snippet")
|
||
}
|
||
groupThreads.append(searchResult)
|
||
groupThreadIds.insert(thread.uniqueId)
|
||
case let contactThread as TSContactThread:
|
||
let searchResult = ConversationSearchResult(thread: threadViewModel, sortKey: sortKey)
|
||
existingConversationAddresses.insert(contactThread.contactAddress)
|
||
contactThreads.append(searchResult)
|
||
default:
|
||
owsFailDebug("unexpected thread: \(type(of: thread))")
|
||
}
|
||
}
|
||
|
||
guard !isCanceled() else {
|
||
return nil
|
||
}
|
||
|
||
FullTextSearchFinder.enumerateObjects(
|
||
searchText: searchText,
|
||
maxResults: remainingAllowedResults,
|
||
transaction: transaction
|
||
) { (groupMember: TSGroupMember, _, stop) in
|
||
guard !isCanceled(), !hasReachedMaxResults else {
|
||
stop = true
|
||
return
|
||
}
|
||
|
||
guard !groupThreadIds.contains(groupMember.groupThreadId) else { return }
|
||
guard let groupThread = TSGroupThread.anyFetchGroupThread(uniqueId: groupMember.groupThreadId, transaction: transaction) else {
|
||
return owsFailDebug("Unexpectedly missing group thread for group member")
|
||
}
|
||
|
||
let threadViewModel = getThreadViewModel(groupThread)
|
||
let sortKey = ConversationSortKey(
|
||
isContactThread: false,
|
||
creationDate: groupThread.creationDate,
|
||
lastInteractionRowId: groupThread.lastInteractionRowId
|
||
)
|
||
|
||
guard let searchResult = GroupSearchResult.withMatchedMembersSnippet(
|
||
thread: threadViewModel,
|
||
sortKey: sortKey,
|
||
searchText: searchText,
|
||
nameResolver: nameResolver,
|
||
transaction: transaction
|
||
) else {
|
||
return owsFailDebug("Unexpectedly failed to determine members snippet")
|
||
}
|
||
|
||
groupThreads.append(searchResult)
|
||
groupThreadIds.insert(groupThread.uniqueId)
|
||
}
|
||
|
||
guard !isCanceled() else {
|
||
return nil
|
||
}
|
||
|
||
FullTextSearchFinder.enumerateObjects(
|
||
searchText: searchText,
|
||
maxResults: remainingAllowedResults,
|
||
transaction: transaction
|
||
) { (account: SignalAccount, _, stop) in
|
||
guard !isCanceled(), !hasReachedMaxResults else {
|
||
stop = true
|
||
return
|
||
}
|
||
appendSignalAccount(account)
|
||
}
|
||
|
||
guard !isCanceled() else {
|
||
return nil
|
||
}
|
||
|
||
FullTextSearchFinder.enumerateObjects(
|
||
searchText: searchText,
|
||
maxResults: remainingAllowedResults,
|
||
transaction: transaction
|
||
) { (recipient: SignalRecipient, _, stop) in
|
||
guard !isCanceled(), !hasReachedMaxResults else {
|
||
stop = true
|
||
return
|
||
}
|
||
|
||
guard recipient.isRegistered else { return }
|
||
|
||
let account = SignalAccount.transientSignalAccount(forSignalRecipient: recipient)
|
||
appendSignalAccount(account)
|
||
}
|
||
|
||
guard !isCanceled() else {
|
||
return nil
|
||
}
|
||
|
||
FullTextSearchFinder.enumerateObjects(
|
||
searchText: searchText,
|
||
maxResults: remainingAllowedResults,
|
||
transaction: transaction
|
||
) { (message: TSMessage, snippet: String?, stop) in
|
||
guard !isCanceled(), !hasReachedMaxResults else {
|
||
stop = true
|
||
return
|
||
}
|
||
let styledSnippet: CVTextValue? = { () -> CVTextValue? in
|
||
guard let snippet else {
|
||
return nil
|
||
}
|
||
let attributeKey = NSAttributedString.Key("OWSSearchMatch")
|
||
let matchStyle = BonMot.StringStyle(
|
||
.xmlRules([
|
||
.style(FullTextSearchFinder.matchTag, StringStyle(.extraAttributes([attributeKey: 0])))
|
||
])
|
||
)
|
||
let matchStyleApplied = snippet.styled(with: matchStyle)
|
||
var styles = [NSRangedValue<MessageBodyRanges.Style>]()
|
||
matchStyleApplied.enumerateAttributes(in: matchStyleApplied.entireRange, using: { attrs, range, _ in
|
||
guard attrs[attributeKey] != nil else {
|
||
return
|
||
}
|
||
styles.append(NSRangedValue(.bold, range: range))
|
||
})
|
||
let mergedMessageBody: MessageBody
|
||
if let messageBody = message.conversationListSearchResultsBody(transaction) {
|
||
mergedMessageBody = messageBody.mergeIntoFirstMatchOfStyledSubstring(matchStyleApplied.string, styles: styles)
|
||
} else {
|
||
let singleStyles = styles.flatMap { style in
|
||
return style.value.contents.map {
|
||
return NSRangedValue($0, range: style.range)
|
||
}
|
||
}
|
||
mergedMessageBody = MessageBody(text: matchStyleApplied.string, ranges: .init(mentions: [:], styles: singleStyles))
|
||
}
|
||
return .messageBody(mergedMessageBody
|
||
.hydrating(mentionHydrator: ContactsMentionHydrator.mentionHydrator(transaction: transaction.asV2Read)))
|
||
}()
|
||
appendMessage(message, snippet: styledSnippet)
|
||
}
|
||
|
||
guard !isCanceled() else {
|
||
return nil
|
||
}
|
||
|
||
if matchesNoteToSelf(searchText: searchText, transaction: transaction) {
|
||
if
|
||
let localAddress = DependenciesBridge.shared.tsAccountManager.localIdentifiers(tx: transaction.asV2Read)?.aciAddress,
|
||
contactsMap[localAddress] == nil
|
||
{
|
||
let localAccount = SignalAccount(address: localAddress)
|
||
let localResult = ContactSearchResult(signalAccount: localAccount, transaction: transaction)
|
||
contactsMap[localAddress] = localResult
|
||
} else {
|
||
owsFailDebug("localAddress was unexpectedly nil")
|
||
}
|
||
}
|
||
|
||
// Only show contacts which were not included in an existing 1:1 conversation.
|
||
var otherContacts: [ContactSearchResult] = contactsMap.values.filter {
|
||
guard
|
||
!DependenciesBridge.shared.recipientHidingManager.isHiddenAddress(
|
||
$0.recipientAddress,
|
||
tx: transaction.asV2Read
|
||
),
|
||
!blockingManager.isAddressBlocked(
|
||
$0.recipientAddress,
|
||
transaction: transaction
|
||
)
|
||
else {
|
||
return false
|
||
}
|
||
return !existingConversationAddresses.contains($0.recipientAddress)
|
||
}
|
||
|
||
// Order the conversation and message results in reverse chronological order.
|
||
// The contact results are pre-sorted by display name.
|
||
contactThreads.sort(by: >)
|
||
groupThreads.sort(by: >)
|
||
let sortedMessages = messages.values.sorted(by: >)
|
||
// Order "other" contact results by display name.
|
||
otherContacts.sort()
|
||
|
||
guard !isCanceled() else {
|
||
return nil
|
||
}
|
||
|
||
return HomeScreenSearchResultSet(
|
||
searchText: searchText,
|
||
contactThreads: contactThreads,
|
||
groupThreads: groupThreads,
|
||
contacts: otherContacts,
|
||
messages: sortedMessages
|
||
)
|
||
}
|
||
|
||
public func searchWithinConversation(
|
||
thread: TSThread,
|
||
searchText: String,
|
||
maxResults: UInt = kDefaultMaxResults,
|
||
transaction: SDSAnyReadTransaction
|
||
) -> ConversationScreenSearchResultSet {
|
||
var messages: [UInt64: MessageSearchResult] = [:]
|
||
|
||
FullTextSearchFinder.enumerateObjects(
|
||
searchText: searchText,
|
||
collections: [
|
||
TSMessage.collection(),
|
||
SignalRecipient.collection()
|
||
],
|
||
maxResults: maxResults,
|
||
transaction: transaction
|
||
) { match, _, stop in
|
||
guard messages.count < maxResults else {
|
||
stop = true
|
||
return
|
||
}
|
||
|
||
func appendMessage(_ message: TSMessage) {
|
||
let messageId = message.uniqueId
|
||
let searchResult = MessageSearchResult(messageId: messageId, sortId: message.sortId)
|
||
messages[message.sortId] = searchResult
|
||
}
|
||
|
||
switch match {
|
||
case let message as TSMessage:
|
||
guard message.uniqueThreadId == thread.uniqueId else {
|
||
return
|
||
}
|
||
|
||
appendMessage(message)
|
||
case let recipient as SignalRecipient:
|
||
guard let aci = recipient.aci else {
|
||
return
|
||
}
|
||
let messagesMentioningAccount = MentionFinder.messagesMentioning(aci: aci, in: thread, tx: transaction)
|
||
messagesMentioningAccount.forEach { appendMessage($0) }
|
||
default:
|
||
owsFailDebug("Unexpected match of type \(type(of: match))")
|
||
}
|
||
}
|
||
|
||
// We want most recent first
|
||
let sortedMessages = messages.values.sorted(by: >)
|
||
|
||
return ConversationScreenSearchResultSet(searchText: searchText, messages: sortedMessages)
|
||
}
|
||
|
||
// MARK: Filtering Signal accounts
|
||
|
||
@objc(filterSignalAccounts:withSearchText:transaction:)
|
||
public func filterSignalAccounts(_ signalAccounts: [SignalAccount], searchText: String, transaction: SDSAnyReadTransaction) -> [SignalAccount] {
|
||
if searchText.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
|
||
return signalAccounts
|
||
}
|
||
|
||
return signalAccounts.filter { signalAccount in
|
||
self.signalAccountSearcher.matches(item: signalAccount, query: searchText, transaction: transaction)
|
||
}
|
||
}
|
||
|
||
private lazy var signalAccountSearcher: Searcher<SignalAccount> = Searcher { (signalAccount: SignalAccount, transaction: SDSAnyReadTransaction) in
|
||
let recipientAddress = signalAccount.recipientAddress
|
||
return self.conversationIndexingString(address: recipientAddress, transaction: transaction)
|
||
}
|
||
|
||
private func conversationIndexingString(address: SignalServiceAddress, transaction: SDSAnyReadTransaction) -> String {
|
||
var result = self.indexingString(address: address, transaction: transaction)
|
||
|
||
if address.isLocalAddress {
|
||
result += " \(MessageStrings.noteToSelf)"
|
||
}
|
||
|
||
return result
|
||
}
|
||
|
||
private func indexingString(address: SignalServiceAddress, transaction: SDSAnyReadTransaction) -> String {
|
||
let displayName = contactsManager.displayName(for: address, transaction: transaction)
|
||
|
||
return "\(address.phoneNumber ?? "") \(displayName)"
|
||
}
|
||
}
|
||
|
||
// MARK: -
|
||
|
||
extension SignalAccount {
|
||
public static func transientSignalAccount(forSignalRecipient signalRecipient: SignalRecipient) -> SignalAccount {
|
||
SignalAccount(address: signalRecipient.address)
|
||
}
|
||
}
|