910 lines
38 KiB
Swift
910 lines
38 KiB
Swift
//
|
|
// Copyright 2020 Signal Messenger, LLC
|
|
// SPDX-License-Identifier: AGPL-3.0-only
|
|
//
|
|
|
|
import Foundation
|
|
|
|
public class CVComponentBodyText: CVComponentBase, CVComponent {
|
|
|
|
public var componentKey: CVComponentKey { .bodyText }
|
|
|
|
struct State: Equatable {
|
|
let bodyText: CVComponentState.BodyText
|
|
let isTextExpanded: Bool
|
|
let searchText: String?
|
|
let hasTapForMore: Bool
|
|
let shouldUseAttributedText: Bool
|
|
let hasPendingMessageRequest: Bool
|
|
fileprivate let items: [CVTextLabel.Item]
|
|
|
|
public var canUseDedicatedCell: Bool {
|
|
if hasTapForMore || searchText != nil {
|
|
return false
|
|
}
|
|
switch bodyText {
|
|
case .bodyText:
|
|
return true
|
|
case .oversizeTextDownloading:
|
|
return false
|
|
case .remotelyDeleted:
|
|
return false
|
|
}
|
|
}
|
|
|
|
var textValue: CVTextValue? {
|
|
bodyText.textValue(isTextExpanded: isTextExpanded)
|
|
}
|
|
}
|
|
private let bodyTextState: State
|
|
|
|
private var bodyText: CVComponentState.BodyText {
|
|
bodyTextState.bodyText
|
|
}
|
|
private var textValue: CVTextValue? {
|
|
bodyTextState.textValue
|
|
}
|
|
private var isTextExpanded: Bool {
|
|
bodyTextState.isTextExpanded
|
|
}
|
|
private var searchText: String? {
|
|
bodyTextState.searchText
|
|
}
|
|
private var hasTapForMore: Bool {
|
|
bodyTextState.hasTapForMore
|
|
}
|
|
private var hasPendingMessageRequest: Bool {
|
|
bodyTextState.hasPendingMessageRequest
|
|
}
|
|
public var shouldUseAttributedText: Bool {
|
|
bodyTextState.shouldUseAttributedText
|
|
}
|
|
|
|
init(itemModel: CVItemModel, bodyTextState: State) {
|
|
self.bodyTextState = bodyTextState
|
|
|
|
super.init(itemModel: itemModel)
|
|
}
|
|
|
|
public func buildComponentView(componentDelegate: CVComponentDelegate) -> CVComponentView {
|
|
CVComponentViewBodyText(componentDelegate: componentDelegate)
|
|
}
|
|
|
|
private static func shouldIgnoreEvents(interaction: TSInteraction) -> Bool {
|
|
guard let outgoingMessage = interaction as? TSOutgoingMessage else {
|
|
return false
|
|
}
|
|
// Ignore taps on links in outgoing messages that haven't been sent yet, as
|
|
// this interferes with "tap to retry".
|
|
return outgoingMessage.messageState != .sent
|
|
}
|
|
private var shouldIgnoreEvents: Bool { Self.shouldIgnoreEvents(interaction: interaction) }
|
|
|
|
// TODO:
|
|
private static let shouldDetectDates = false
|
|
|
|
private static func buildDataDetector(shouldAllowLinkification: Bool) -> NSDataDetector? {
|
|
var checkingTypes = NSTextCheckingResult.CheckingType()
|
|
if shouldAllowLinkification {
|
|
checkingTypes.insert(.link)
|
|
}
|
|
checkingTypes.insert(.address)
|
|
checkingTypes.insert(.phoneNumber)
|
|
if shouldDetectDates {
|
|
checkingTypes.insert(.date)
|
|
}
|
|
|
|
do {
|
|
return try NSDataDetector(types: checkingTypes.rawValue)
|
|
} catch {
|
|
owsFailDebug("Error: \(error)")
|
|
return nil
|
|
}
|
|
}
|
|
|
|
private static var dataDetectorWithLinks: NSDataDetector? = {
|
|
buildDataDetector(shouldAllowLinkification: true)
|
|
}()
|
|
|
|
private static var dataDetectorWithoutLinks: NSDataDetector? = {
|
|
buildDataDetector(shouldAllowLinkification: false)
|
|
}()
|
|
|
|
// DataDetectors are expensive to build, so we reuse them.
|
|
private static func dataDetector(shouldAllowLinkification: Bool) -> NSDataDetector? {
|
|
shouldAllowLinkification ? dataDetectorWithLinks : dataDetectorWithoutLinks
|
|
}
|
|
|
|
private static let unfairLock = UnfairLock()
|
|
|
|
private static func detectItems(text: String,
|
|
attributedString: NSAttributedString?,
|
|
hasPendingMessageRequest: Bool,
|
|
shouldAllowLinkification: Bool,
|
|
textWasTruncated: Bool) -> [CVTextLabel.Item] {
|
|
|
|
// Use a lock to ensure that measurement on and off the main thread
|
|
// don't conflict.
|
|
unfairLock.withLock {
|
|
guard !hasPendingMessageRequest else {
|
|
// Do not linkify if there is a pending message request.
|
|
return []
|
|
}
|
|
|
|
if textWasTruncated {
|
|
owsAssertDebug(text.hasSuffix(DisplayableText.truncatedTextSuffix))
|
|
}
|
|
|
|
var items = [CVTextLabel.Item]()
|
|
// Detect and discard overlapping items, preferring mentions to data items.
|
|
func hasItemOverlap(_ newItem: CVTextLabel.Item) -> Bool {
|
|
for oldItem in items {
|
|
if let overlap = oldItem.range.intersection(newItem.range),
|
|
overlap.length > 0 {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Add mentions.
|
|
if let attributedString = attributedString {
|
|
attributedString.enumerateMentions { mention, range, _ in
|
|
guard let mention = mention else { return }
|
|
let mentionItem = CVTextLabel.MentionItem(mention: mention, range: range)
|
|
let item: CVTextLabel.Item = .mention(mentionItem: mentionItem)
|
|
guard !hasItemOverlap(item) else {
|
|
owsFailDebug("Item overlap.")
|
|
return
|
|
}
|
|
items.append(item)
|
|
}
|
|
}
|
|
|
|
// NSDataDetector and UIDataDetector behavior should be aligned.
|
|
//
|
|
// TODO: We might want to move this detection logic into
|
|
// DisplayableText so that we can leverage caching.
|
|
guard let detector = dataDetector(shouldAllowLinkification: shouldAllowLinkification) else {
|
|
// If the data detectors can't be built, default to using attributed text.
|
|
owsFailDebug("Could not build dataDetector.")
|
|
return []
|
|
}
|
|
for match in detector.matches(in: text, options: [], range: text.entireRange) {
|
|
if textWasTruncated {
|
|
if NSMaxRange(match.range) == NSMaxRange(text.entireRange) {
|
|
// This implies that the data detector *included* our "…" suffix.
|
|
// We don't expect this to happen, but if it does it's certainly not intended!
|
|
continue
|
|
}
|
|
if (text as NSString).substring(after: match.range) == DisplayableText.truncatedTextSuffix {
|
|
// More likely the item right before the "…" was detected.
|
|
// Conservatively assume that the item was truncated.
|
|
continue
|
|
}
|
|
}
|
|
|
|
guard let snippet = (text as NSString).substring(with: match.range).strippedOrNil else {
|
|
owsFailDebug("Invalid snippet.")
|
|
continue
|
|
}
|
|
|
|
let matchUrl = match.url
|
|
|
|
let dataType: CVTextLabel.DataItem.DataType
|
|
var customUrl: URL?
|
|
let resultType: NSTextCheckingResult.CheckingType = match.resultType
|
|
if resultType.contains(.orthography) {
|
|
Logger.verbose("orthography")
|
|
continue
|
|
} else if resultType.contains(.spelling) {
|
|
Logger.verbose("spelling")
|
|
continue
|
|
} else if resultType.contains(.grammar) {
|
|
Logger.verbose("grammar")
|
|
continue
|
|
} else if resultType.contains(.date) {
|
|
dataType = .date
|
|
|
|
guard matchUrl == nil else {
|
|
// Skip building customUrl; we already have a URL.
|
|
break
|
|
}
|
|
|
|
// NSTextCheckingResult.date is in GMT.
|
|
guard let gmtDate = match.date else {
|
|
owsFailDebug("Missing date.")
|
|
continue
|
|
}
|
|
// "calshow:" URLs expect GMT.
|
|
let timeInterval = gmtDate.timeIntervalSinceReferenceDate
|
|
// I'm not sure if there's official docs around these links.
|
|
guard let calendarUrl = URL(string: "calshow:\(timeInterval)") else {
|
|
owsFailDebug("Couldn't build calendarUrl.")
|
|
continue
|
|
}
|
|
customUrl = calendarUrl
|
|
} else if resultType.contains(.address) {
|
|
Logger.verbose("address")
|
|
|
|
dataType = .address
|
|
|
|
guard matchUrl == nil else {
|
|
// Skip building customUrl; we already have a URL.
|
|
break
|
|
}
|
|
|
|
// https://developer.apple.com/library/archive/featuredarticles/iPhoneURLScheme_Reference/MapLinks/MapLinks.html
|
|
guard let urlEncodedAddress = snippet.encodeURIComponent else {
|
|
owsFailDebug("Could not URL encode address.")
|
|
continue
|
|
}
|
|
let urlString = "https://maps.apple.com/?q=" + urlEncodedAddress
|
|
guard let mapUrl = URL(string: urlString) else {
|
|
owsFailDebug("Couldn't build mapUrl.")
|
|
continue
|
|
}
|
|
customUrl = mapUrl
|
|
} else if resultType.contains(.link) {
|
|
if let url = matchUrl,
|
|
url.absoluteString.lowercased().hasPrefix("mailto:"),
|
|
!snippet.lowercased().hasPrefix("mailto:") {
|
|
Logger.verbose("emailAddress")
|
|
dataType = .emailAddress
|
|
} else {
|
|
Logger.verbose("link")
|
|
dataType = .link
|
|
}
|
|
} else if resultType.contains(.quote) {
|
|
Logger.verbose("quote")
|
|
continue
|
|
} else if resultType.contains(.dash) {
|
|
Logger.verbose("dash")
|
|
continue
|
|
} else if resultType.contains(.replacement) {
|
|
Logger.verbose("replacement")
|
|
continue
|
|
} else if resultType.contains(.correction) {
|
|
Logger.verbose("correction")
|
|
continue
|
|
} else if resultType.contains(.regularExpression) {
|
|
Logger.verbose("regularExpression")
|
|
continue
|
|
} else if resultType.contains(.phoneNumber) {
|
|
Logger.verbose("phoneNumber")
|
|
|
|
dataType = .phoneNumber
|
|
|
|
guard matchUrl == nil else {
|
|
// Skip building customUrl; we already have a URL.
|
|
break
|
|
}
|
|
|
|
// https://developer.apple.com/library/archive/featuredarticles/iPhoneURLScheme_Reference/PhoneLinks/PhoneLinks.html
|
|
let characterSet = CharacterSet(charactersIn: "+0123456789")
|
|
guard let phoneNumber = snippet.components(separatedBy: characterSet.inverted).joined().nilIfEmpty else {
|
|
owsFailDebug("Invalid phoneNumber.")
|
|
continue
|
|
}
|
|
let urlString = "tel:" + phoneNumber
|
|
guard let phoneNumberUrl = URL(string: urlString) else {
|
|
owsFailDebug("Couldn't build phoneNumberUrl.")
|
|
continue
|
|
}
|
|
customUrl = phoneNumberUrl
|
|
} else if resultType.contains(.transitInformation) {
|
|
Logger.verbose("transitInformation")
|
|
|
|
dataType = .transitInformation
|
|
|
|
guard matchUrl == nil else {
|
|
// Skip building customUrl; we already have a URL.
|
|
break
|
|
}
|
|
|
|
guard let components = match.components,
|
|
let airline = components[.airline]?.nilIfEmpty,
|
|
let flight = components[.flight]?.nilIfEmpty else {
|
|
Logger.warn("Missing components.")
|
|
continue
|
|
}
|
|
let query = airline + " " + flight
|
|
guard let urlEncodedQuery = query.encodeURIComponent else {
|
|
owsFailDebug("Could not URL encode query.")
|
|
continue
|
|
}
|
|
let urlString = "https://www.google.com/?q=" + urlEncodedQuery
|
|
guard let transitUrl = URL(string: urlString) else {
|
|
owsFailDebug("Couldn't build transitUrl.")
|
|
continue
|
|
}
|
|
customUrl = transitUrl
|
|
} else {
|
|
let snippet = (text as NSString).substring(with: match.range)
|
|
Logger.verbose("snippet: '\(snippet)'")
|
|
owsFailDebug("Unknown link type: \(resultType.rawValue)")
|
|
continue
|
|
}
|
|
|
|
guard let url = customUrl ?? matchUrl else {
|
|
owsFailDebug("Missing url: \(dataType).")
|
|
continue
|
|
}
|
|
|
|
let dataItem = CVTextLabel.DataItem(dataType: dataType,
|
|
range: match.range,
|
|
snippet: snippet,
|
|
url: url)
|
|
let item: CVTextLabel.Item = .dataItem(dataItem: dataItem)
|
|
guard !hasItemOverlap(item) else {
|
|
owsFailDebug("Item overlap.")
|
|
continue
|
|
}
|
|
items.append(item)
|
|
}
|
|
return items
|
|
}
|
|
}
|
|
|
|
static func buildState(interaction: TSInteraction,
|
|
bodyText: CVComponentState.BodyText,
|
|
viewStateSnapshot: CVViewStateSnapshot,
|
|
hasTapForMore: Bool,
|
|
hasPendingMessageRequest: Bool) -> State {
|
|
let textExpansion = viewStateSnapshot.textExpansion
|
|
let searchText = viewStateSnapshot.searchText
|
|
let isTextExpanded = textExpansion.isTextExpanded(interactionId: interaction.uniqueId)
|
|
|
|
let items: [CVTextLabel.Item]
|
|
var shouldUseAttributedText = false
|
|
if let displayableText = bodyText.displayableText,
|
|
let textValue = bodyText.textValue(isTextExpanded: isTextExpanded) {
|
|
|
|
let shouldAllowLinkification = displayableText.shouldAllowLinkification
|
|
let textWasTruncated = !isTextExpanded && displayableText.isTextTruncated
|
|
|
|
switch textValue {
|
|
case .text(let text):
|
|
items = detectItems(text: text,
|
|
attributedString: nil,
|
|
hasPendingMessageRequest: hasPendingMessageRequest,
|
|
shouldAllowLinkification: shouldAllowLinkification,
|
|
textWasTruncated: textWasTruncated)
|
|
|
|
// UILabels are much cheaper than UITextViews, and we can
|
|
// usually use them for rendering body text.
|
|
//
|
|
// We need to use attributed text in a UITextViews if:
|
|
//
|
|
// * We're displaying search results (and need to highlight matches).
|
|
// * The text value is an attributed string (has mentions).
|
|
// * The text value should be linkified.
|
|
if searchText != nil {
|
|
shouldUseAttributedText = true
|
|
} else {
|
|
shouldUseAttributedText = !items.isEmpty
|
|
}
|
|
case .attributedText(let attributedText):
|
|
items = detectItems(text: attributedText.string,
|
|
attributedString: attributedText,
|
|
hasPendingMessageRequest: hasPendingMessageRequest,
|
|
shouldAllowLinkification: shouldAllowLinkification,
|
|
textWasTruncated: textWasTruncated)
|
|
shouldUseAttributedText = true
|
|
}
|
|
} else {
|
|
items = []
|
|
}
|
|
|
|
return State(bodyText: bodyText,
|
|
isTextExpanded: isTextExpanded,
|
|
searchText: searchText,
|
|
hasTapForMore: hasTapForMore,
|
|
shouldUseAttributedText: shouldUseAttributedText,
|
|
hasPendingMessageRequest: hasPendingMessageRequest,
|
|
items: items)
|
|
}
|
|
|
|
static func buildComponentState(message: TSMessage,
|
|
transaction: SDSAnyReadTransaction) throws -> CVComponentState.BodyText? {
|
|
|
|
func build(displayableText: DisplayableText) -> CVComponentState.BodyText? {
|
|
guard !displayableText.fullTextValue.stringValue.isEmpty else {
|
|
return nil
|
|
}
|
|
return .bodyText(displayableText: displayableText)
|
|
}
|
|
|
|
// TODO: We might want to treat text that is completely stripped
|
|
// as not present.
|
|
if let oversizeTextAttachment = message.oversizeTextAttachment(with: transaction.unwrapGrdbRead) {
|
|
if let oversizeTextAttachmentStream = oversizeTextAttachment as? TSAttachmentStream {
|
|
let displayableText = CVComponentState.displayableBodyText(oversizeTextAttachment: oversizeTextAttachmentStream,
|
|
ranges: message.bodyRanges,
|
|
interaction: message,
|
|
transaction: transaction)
|
|
return build(displayableText: displayableText)
|
|
} else if nil != oversizeTextAttachment as? TSAttachmentPointer {
|
|
// TODO: Handle backup restore.
|
|
// TODO: If there's media, should we display that while the oversize text is downloading?
|
|
return .oversizeTextDownloading
|
|
} else {
|
|
throw OWSAssertionError("Invalid oversizeTextAttachment.")
|
|
}
|
|
} else if let body = message.body, !body.isEmpty {
|
|
let displayableText = CVComponentState.displayableBodyText(text: body,
|
|
ranges: message.bodyRanges,
|
|
interaction: message,
|
|
transaction: transaction)
|
|
return build(displayableText: displayableText)
|
|
} else {
|
|
// No body text.
|
|
return nil
|
|
}
|
|
}
|
|
|
|
public var textMessageFont: UIFont {
|
|
owsAssertDebug(DisplayableText.kMaxJumbomojiCount == 5)
|
|
|
|
if let jumbomojiCount = bodyText.jumbomojiCount {
|
|
let basePointSize = UIFont.ows_dynamicTypeBodyClamped.pointSize
|
|
switch jumbomojiCount {
|
|
case 0:
|
|
break
|
|
case 1:
|
|
return UIFont.ows_regularFont(withSize: basePointSize * 3.5)
|
|
case 2:
|
|
return UIFont.ows_regularFont(withSize: basePointSize * 3.0)
|
|
case 3:
|
|
return UIFont.ows_regularFont(withSize: basePointSize * 2.75)
|
|
case 4:
|
|
return UIFont.ows_regularFont(withSize: basePointSize * 2.5)
|
|
case 5:
|
|
return UIFont.ows_regularFont(withSize: basePointSize * 2.25)
|
|
default:
|
|
owsFailDebug("Unexpected jumbomoji count: \(jumbomojiCount)")
|
|
}
|
|
}
|
|
|
|
return UIFont.ows_dynamicTypeBody
|
|
}
|
|
|
|
private var bodyTextColor: UIColor {
|
|
guard let message = interaction as? TSMessage else {
|
|
return .black
|
|
}
|
|
return conversationStyle.bubbleTextColor(message: message)
|
|
}
|
|
|
|
private var textSelectionStyling: [NSAttributedString.Key: Any] {
|
|
var foregroundColor: UIColor = .black
|
|
if let message = interaction as? TSMessage {
|
|
foregroundColor = conversationStyle.bubbleSecondaryTextColor(isIncoming: message.isIncoming)
|
|
}
|
|
|
|
return [
|
|
.underlineStyle: NSUnderlineStyle.single.rawValue,
|
|
.underlineColor: foregroundColor,
|
|
.foregroundColor: foregroundColor
|
|
]
|
|
}
|
|
|
|
public func bodyTextLabelConfig(textViewConfig: CVTextViewConfig) -> CVTextLabel.Config {
|
|
CVTextLabel.Config(attributedString: textViewConfig.text.attributedString,
|
|
font: textViewConfig.font,
|
|
textColor: textViewConfig.textColor,
|
|
selectionStyling: textSelectionStyling,
|
|
textAlignment: textViewConfig.textAlignment ?? .natural,
|
|
lineBreakMode: .byWordWrapping,
|
|
numberOfLines: 0,
|
|
cacheKey: textViewConfig.cacheKey,
|
|
items: bodyTextState.items)
|
|
}
|
|
|
|
public func bodyTextLabelConfig(labelConfig: CVLabelConfig) -> CVTextLabel.Config {
|
|
// CVTextLabel requires that attributedString has
|
|
// default attributes applied to the entire string's range.
|
|
let textAlignment: NSTextAlignment = labelConfig.textAlignment ?? .natural
|
|
let paragraphStyle = NSMutableParagraphStyle()
|
|
paragraphStyle.alignment = textAlignment
|
|
let attributedText = labelConfig.attributedString.mutableCopy() as! NSMutableAttributedString
|
|
attributedText.addAttributes(
|
|
[
|
|
.font: labelConfig.font,
|
|
.foregroundColor: labelConfig.textColor,
|
|
.paragraphStyle: paragraphStyle
|
|
],
|
|
range: attributedText.entireRange
|
|
)
|
|
|
|
return CVTextLabel.Config(attributedString: attributedText,
|
|
font: labelConfig.font,
|
|
textColor: labelConfig.textColor,
|
|
selectionStyling: textSelectionStyling,
|
|
textAlignment: textAlignment,
|
|
lineBreakMode: .byWordWrapping,
|
|
numberOfLines: 0,
|
|
cacheKey: labelConfig.cacheKey,
|
|
items: bodyTextState.items)
|
|
}
|
|
|
|
public func configureForRendering(componentView: CVComponentView,
|
|
cellMeasurement: CVCellMeasurement,
|
|
componentDelegate: CVComponentDelegate) {
|
|
AssertIsOnMainThread()
|
|
guard let componentView = componentView as? CVComponentViewBodyText else {
|
|
owsFailDebug("Unexpected componentView.")
|
|
return
|
|
}
|
|
|
|
let bodyTextLabelConfig = buildBodyTextLabelConfig()
|
|
configureForBodyTextLabel(componentView: componentView,
|
|
bodyTextLabelConfig: bodyTextLabelConfig,
|
|
cellMeasurement: cellMeasurement)
|
|
}
|
|
|
|
private func configureForBodyTextLabel(componentView: CVComponentViewBodyText,
|
|
bodyTextLabelConfig: CVTextLabel.Config,
|
|
cellMeasurement: CVCellMeasurement) {
|
|
AssertIsOnMainThread()
|
|
|
|
let bodyTextLabel = componentView.bodyTextLabel
|
|
bodyTextLabel.configureForRendering(config: bodyTextLabelConfig)
|
|
|
|
if bodyTextLabel.view.superview == nil {
|
|
let stackView = componentView.stackView
|
|
stackView.reset()
|
|
stackView.configure(config: stackViewConfig,
|
|
cellMeasurement: cellMeasurement,
|
|
measurementKey: Self.measurementKey_stackView,
|
|
subviews: [ bodyTextLabel.view ])
|
|
}
|
|
}
|
|
|
|
public func buildBodyTextLabelConfig() -> CVTextLabel.Config {
|
|
switch bodyText {
|
|
case .bodyText(let displayableText):
|
|
return bodyTextLabelConfig(textViewConfig: textConfig(displayableText: displayableText))
|
|
case .oversizeTextDownloading:
|
|
return bodyTextLabelConfig(labelConfig: labelConfigForOversizeTextDownloading)
|
|
case .remotelyDeleted:
|
|
return bodyTextLabelConfig(labelConfig: labelConfigForRemotelyDeleted)
|
|
}
|
|
}
|
|
|
|
private var stackViewConfig: CVStackViewConfig {
|
|
CVStackViewConfig(axis: .vertical,
|
|
alignment: .fill,
|
|
spacing: 0,
|
|
layoutMargins: .zero)
|
|
}
|
|
|
|
private var labelConfigForRemotelyDeleted: CVLabelConfig {
|
|
let text = (isIncoming
|
|
? NSLocalizedString("THIS_MESSAGE_WAS_DELETED", comment: "text indicating the message was remotely deleted")
|
|
: NSLocalizedString("YOU_DELETED_THIS_MESSAGE", comment: "text indicating the message was remotely deleted by you"))
|
|
return CVLabelConfig(text: text,
|
|
font: textMessageFont.ows_italic,
|
|
textColor: bodyTextColor,
|
|
numberOfLines: 0,
|
|
lineBreakMode: .byWordWrapping,
|
|
textAlignment: .center)
|
|
}
|
|
|
|
private var labelConfigForOversizeTextDownloading: CVLabelConfig {
|
|
let text = NSLocalizedString("MESSAGE_STATUS_DOWNLOADING",
|
|
comment: "message status while message is downloading.")
|
|
return CVLabelConfig(text: text,
|
|
font: textMessageFont.ows_italic,
|
|
textColor: bodyTextColor,
|
|
numberOfLines: 0,
|
|
lineBreakMode: .byWordWrapping,
|
|
textAlignment: .center)
|
|
}
|
|
|
|
private typealias TextConfig = CVTextViewConfig
|
|
|
|
private func textConfig(displayableText: DisplayableText) -> TextConfig {
|
|
let textValue = displayableText.textValue(isTextExpanded: isTextExpanded)
|
|
return self.textViewConfig(displayableText: displayableText,
|
|
attributedText: textValue.attributedString)
|
|
}
|
|
|
|
public static func configureTextView(_ textView: UITextView,
|
|
interaction: TSInteraction,
|
|
displayableText: DisplayableText) {
|
|
let dataDetectorTypes: UIDataDetectorTypes = {
|
|
// If we're link-ifying with NSDataDetector, UITextView doesn't need to do data detection.
|
|
guard !shouldIgnoreEvents(interaction: interaction),
|
|
displayableText.shouldAllowLinkification else {
|
|
return []
|
|
}
|
|
return [.link, .address, .calendarEvent, .phoneNumber]
|
|
}()
|
|
if textView.dataDetectorTypes != dataDetectorTypes {
|
|
// Setting dataDetectorTypes is expensive, so we only
|
|
// update the property if the value has changed.
|
|
textView.dataDetectorTypes = dataDetectorTypes
|
|
}
|
|
}
|
|
|
|
public enum LinkifyStyle {
|
|
case linkAttribute
|
|
case underlined(bodyTextColor: UIColor)
|
|
}
|
|
|
|
private func linkifyData(attributedText: NSMutableAttributedString) {
|
|
Self.linkifyData(attributedText: attributedText,
|
|
linkifyStyle: .underlined(bodyTextColor: bodyTextColor),
|
|
items: bodyTextState.items)
|
|
}
|
|
|
|
public static func linkifyData(attributedText: NSMutableAttributedString,
|
|
linkifyStyle: LinkifyStyle,
|
|
hasPendingMessageRequest: Bool,
|
|
shouldAllowLinkification: Bool,
|
|
textWasTruncated: Bool) {
|
|
|
|
let items = detectItems(text: attributedText.string,
|
|
attributedString: attributedText,
|
|
hasPendingMessageRequest: hasPendingMessageRequest,
|
|
shouldAllowLinkification: shouldAllowLinkification,
|
|
textWasTruncated: textWasTruncated)
|
|
Self.linkifyData(attributedText: attributedText,
|
|
linkifyStyle: linkifyStyle,
|
|
items: items)
|
|
}
|
|
|
|
private static func linkifyData(attributedText: NSMutableAttributedString,
|
|
linkifyStyle: LinkifyStyle,
|
|
items: [CVTextLabel.Item]) {
|
|
|
|
// Sort so that we can detect overlap.
|
|
let items = items.sorted {
|
|
$0.range.location < $1.range.location
|
|
}
|
|
|
|
var lastIndex: Int = 0
|
|
for item in items {
|
|
let range = item.range
|
|
|
|
guard range.location >= lastIndex else {
|
|
owsFailDebug("Overlapping ranges.")
|
|
continue
|
|
}
|
|
switch item {
|
|
case .mention, .referencedUser:
|
|
// Do nothing; mentions and referenced users are already styled.
|
|
continue
|
|
case .dataItem(let dataItem):
|
|
guard let link = dataItem.url.absoluteString.nilIfEmpty else {
|
|
owsFailDebug("Could not build data link.")
|
|
continue
|
|
}
|
|
|
|
switch linkifyStyle {
|
|
case .linkAttribute:
|
|
attributedText.addAttribute(.link, value: link, range: range)
|
|
case .underlined(let bodyTextColor):
|
|
attributedText.addAttribute(.underlineStyle, value: NSUnderlineStyle.single.rawValue, range: range)
|
|
attributedText.addAttribute(.underlineColor, value: bodyTextColor, range: range)
|
|
}
|
|
|
|
lastIndex = max(lastIndex, range.location + range.length)
|
|
}
|
|
}
|
|
}
|
|
|
|
private func textViewConfig(displayableText: DisplayableText,
|
|
attributedText attributedTextParam: NSAttributedString) -> CVTextViewConfig {
|
|
|
|
// Honor dynamic type in the message bodies.
|
|
let linkTextAttributes: [NSAttributedString.Key: Any] = [
|
|
NSAttributedString.Key.foregroundColor: bodyTextColor,
|
|
NSAttributedString.Key.underlineStyle: NSUnderlineStyle.single.rawValue
|
|
]
|
|
|
|
let textAlignment = (isTextExpanded
|
|
? displayableText.fullTextNaturalAlignment
|
|
: displayableText.displayTextNaturalAlignment)
|
|
|
|
let paragraphStyle = NSMutableParagraphStyle()
|
|
paragraphStyle.alignment = textAlignment
|
|
|
|
let attributedText = attributedTextParam.mutableCopy() as! NSMutableAttributedString
|
|
attributedText.addAttributes(
|
|
[
|
|
.font: textMessageFont,
|
|
.foregroundColor: bodyTextColor,
|
|
.paragraphStyle: paragraphStyle
|
|
],
|
|
range: attributedText.entireRange
|
|
)
|
|
linkifyData(attributedText: attributedText)
|
|
|
|
if let searchText = searchText,
|
|
searchText.count >= ConversationSearchController.kMinimumSearchTextLength {
|
|
let searchableText = FullTextSearchFinder.normalize(text: searchText)
|
|
let pattern = NSRegularExpression.escapedPattern(for: searchableText)
|
|
do {
|
|
let regex = try NSRegularExpression(pattern: pattern, options: [.caseInsensitive])
|
|
for match in regex.matches(in: attributedText.string,
|
|
options: [.withoutAnchoringBounds],
|
|
range: attributedText.string.entireRange) {
|
|
owsAssertDebug(match.range.length >= ConversationSearchController.kMinimumSearchTextLength)
|
|
attributedText.addAttribute(.backgroundColor, value: UIColor.yellow, range: match.range)
|
|
attributedText.addAttribute(.foregroundColor, value: UIColor.ows_black, range: match.range)
|
|
}
|
|
} catch {
|
|
owsFailDebug("Error: \(error)")
|
|
}
|
|
}
|
|
|
|
var extraCacheKeyFactors = [String]()
|
|
if hasPendingMessageRequest {
|
|
extraCacheKeyFactors.append("hasPendingMessageRequest")
|
|
}
|
|
extraCacheKeyFactors.append("items: \(!bodyTextState.items.isEmpty)")
|
|
|
|
return CVTextViewConfig(attributedText: attributedText,
|
|
font: textMessageFont,
|
|
textColor: bodyTextColor,
|
|
textAlignment: textAlignment,
|
|
linkTextAttributes: linkTextAttributes,
|
|
extraCacheKeyFactors: extraCacheKeyFactors)
|
|
}
|
|
|
|
private static let measurementKey_stackView = "CVComponentBodyText.measurementKey_stackView"
|
|
private static let measurementKey_textMeasurement = "CVComponentBodyText.measurementKey_textMeasurement"
|
|
private static let measurementKey_maxWidth = "CVComponentBodyText.measurementKey_maxWidth"
|
|
|
|
// Extract the max width used for measuring for this component.
|
|
public static func bodyTextMaxWidth(measurementBuilder: CVCellMeasurement.Builder) -> CGFloat? {
|
|
measurementBuilder.getValue(key: measurementKey_maxWidth)
|
|
}
|
|
|
|
// Extract the overall measurement for this component.
|
|
public static func bodyTextMeasurement(measurementBuilder: CVCellMeasurement.Builder) -> CVTextLabel.Measurement? {
|
|
measurementBuilder.getObject(key: measurementKey_textMeasurement) as? CVTextLabel.Measurement
|
|
}
|
|
|
|
public func measure(maxWidth: CGFloat, measurementBuilder: CVCellMeasurement.Builder) -> CGSize {
|
|
owsAssertDebug(maxWidth > 0)
|
|
let maxWidth = max(maxWidth, 0)
|
|
|
|
let bodyTextLabelConfig = buildBodyTextLabelConfig()
|
|
|
|
let textMeasurement = CVText.measureBodyTextLabel(config: bodyTextLabelConfig, maxWidth: maxWidth)
|
|
measurementBuilder.setObject(key: Self.measurementKey_textMeasurement, value: textMeasurement)
|
|
measurementBuilder.setValue(key: Self.measurementKey_maxWidth, value: maxWidth)
|
|
let textSize = textMeasurement.size.ceil
|
|
let textInfo = textSize.asManualSubviewInfo
|
|
let stackMeasurement = ManualStackView.measure(config: stackViewConfig,
|
|
measurementBuilder: measurementBuilder,
|
|
measurementKey: Self.measurementKey_stackView,
|
|
subviewInfos: [ textInfo ],
|
|
maxWidth: maxWidth)
|
|
return stackMeasurement.measuredSize
|
|
}
|
|
|
|
// MARK: - Events
|
|
|
|
public override func handleTap(sender: UITapGestureRecognizer,
|
|
componentDelegate: CVComponentDelegate,
|
|
componentView: CVComponentView,
|
|
renderItem: CVRenderItem) -> Bool {
|
|
guard let componentView = componentView as? CVComponentViewBodyText else {
|
|
owsFailDebug("Unexpected componentView.")
|
|
return false
|
|
}
|
|
|
|
guard !shouldIgnoreEvents else {
|
|
return false
|
|
}
|
|
|
|
let bodyTextLabel = componentView.bodyTextLabel
|
|
if let item = bodyTextLabel.itemForGesture(sender: sender) {
|
|
componentDelegate.didTapBodyTextItem(item)
|
|
return true
|
|
}
|
|
|
|
if hasTapForMore {
|
|
let itemViewModel = CVItemViewModelImpl(renderItem: renderItem)
|
|
componentDelegate.didTapTruncatedTextMessage(itemViewModel)
|
|
return true
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
public override func findLongPressHandler(sender: UIGestureRecognizer,
|
|
componentDelegate: CVComponentDelegate,
|
|
componentView: CVComponentView,
|
|
renderItem: CVRenderItem) -> CVLongPressHandler? {
|
|
|
|
guard let componentView = componentView as? CVComponentViewBodyText else {
|
|
owsFailDebug("Unexpected componentView.")
|
|
return nil
|
|
}
|
|
|
|
guard !shouldIgnoreEvents else {
|
|
return nil
|
|
}
|
|
|
|
let bodyTextLabel = componentView.bodyTextLabel
|
|
guard let item = bodyTextLabel.itemForGesture(sender: sender) else {
|
|
return nil
|
|
}
|
|
return CVLongPressHandler(delegate: componentDelegate,
|
|
renderItem: renderItem,
|
|
gestureLocation: .bodyText(item: item))
|
|
}
|
|
|
|
// MARK: -
|
|
|
|
fileprivate class BodyTextRootView: ManualStackView {}
|
|
|
|
public static func findBodyTextRootView(_ view: UIView) -> UIView? {
|
|
if view is BodyTextRootView {
|
|
return view
|
|
}
|
|
for subview in view.subviews {
|
|
if let rootView = findBodyTextRootView(subview) {
|
|
return rootView
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// MARK: -
|
|
|
|
// Used for rendering some portion of an Conversation View item.
|
|
// It could be the entire item or some part thereof.
|
|
public class CVComponentViewBodyText: NSObject, CVComponentView {
|
|
|
|
public weak var componentDelegate: CVComponentDelegate?
|
|
|
|
fileprivate let stackView = BodyTextRootView(name: "bodyText")
|
|
|
|
public let bodyTextLabel = CVTextLabel()
|
|
|
|
public var isDedicatedCellView = false
|
|
|
|
public var rootView: UIView {
|
|
stackView
|
|
}
|
|
|
|
required init(componentDelegate: CVComponentDelegate) {
|
|
self.componentDelegate = componentDelegate
|
|
|
|
super.init()
|
|
}
|
|
|
|
public func setIsCellVisible(_ isCellVisible: Bool) {}
|
|
|
|
public func reset() {
|
|
if !isDedicatedCellView {
|
|
stackView.reset()
|
|
}
|
|
|
|
bodyTextLabel.reset()
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: -
|
|
|
|
extension CVComponentBodyText: CVAccessibilityComponent {
|
|
public var accessibilityDescription: String {
|
|
switch bodyText {
|
|
case .bodyText(let displayableText):
|
|
// NOTE: we use the full text.
|
|
return displayableText.fullTextValue.stringValue
|
|
case .oversizeTextDownloading:
|
|
return labelConfigForOversizeTextDownloading.stringValue
|
|
case .remotelyDeleted:
|
|
return labelConfigForRemotelyDeleted.stringValue
|
|
}
|
|
}
|
|
}
|