519 lines
19 KiB
Swift
519 lines
19 KiB
Swift
//
|
|
// Copyright 2020 Signal Messenger, LLC
|
|
// SPDX-License-Identifier: AGPL-3.0-only
|
|
//
|
|
|
|
import Contacts
|
|
import ContactsUI
|
|
import LibSignalClient
|
|
import SafariServices
|
|
import SignalMessaging
|
|
import SignalServiceKit
|
|
|
|
@objc
|
|
public protocol ContactsViewHelperObserver: AnyObject {
|
|
func contactsViewHelperDidUpdateContacts()
|
|
}
|
|
|
|
public class ContactsViewHelper: Dependencies {
|
|
|
|
public init() {
|
|
AppReadiness.runNowOrWhenUIDidBecomeReadySync {
|
|
// setup() - especially updateContacts() - can
|
|
// be expensive, so we don't want to run that
|
|
// directly in runNowOrWhenAppDidBecomeReadySync().
|
|
// That could cause 0x8badf00d crashes.
|
|
//
|
|
// On the other hand, the user might quickly
|
|
// open a view (like the compose view) that uses
|
|
// this helper. If the helper hasn't completed
|
|
// setup, that view won't be able to display a
|
|
// list of users to pick from. Therefore, we
|
|
// can't use runNowOrWhenAppDidBecomeReadyAsync()
|
|
// which might not run for many seconds after
|
|
// the app becomes ready.
|
|
//
|
|
// Therefore we dispatch async to the main queue.
|
|
// We'll run very soon after app UI becomes ready,
|
|
// without introducing the risk of a 0x8badf00d
|
|
// crash.
|
|
DispatchQueue.main.async {
|
|
self.setup()
|
|
}
|
|
}
|
|
}
|
|
|
|
deinit {
|
|
notificationObservers.forEach { NotificationCenter.default.removeObserver($0) }
|
|
}
|
|
|
|
private func setup() {
|
|
guard !CurrentAppContext().isNSE else { return }
|
|
|
|
updateContacts()
|
|
setupNotificationObservations()
|
|
}
|
|
|
|
// MARK: Notifications
|
|
|
|
private var notificationObservers = [Any]()
|
|
|
|
private func setupNotificationObservations() {
|
|
notificationObservers.append(contentsOf: [
|
|
NotificationCenter.default.addObserver(
|
|
forName: .OWSContactsManagerSignalAccountsDidChange,
|
|
object: nil,
|
|
queue: nil,
|
|
using: { [weak self] _ in
|
|
self?.updateContacts()
|
|
}
|
|
),
|
|
NotificationCenter.default.addObserver(
|
|
forName: .profileWhitelistDidChange,
|
|
object: nil,
|
|
queue: nil,
|
|
using: { [weak self] _ in
|
|
self?.updateContacts()
|
|
}
|
|
),
|
|
NotificationCenter.default.addObserver(
|
|
forName: BlockingManager.blockListDidChange,
|
|
object: nil,
|
|
queue: nil,
|
|
using: { [weak self] _ in
|
|
self?.updateContacts()
|
|
}
|
|
),
|
|
NotificationCenter.default.addObserver(
|
|
forName: RecipientHidingManagerImpl.hideListDidChange,
|
|
object: nil,
|
|
queue: nil,
|
|
using: { [weak self] _ in
|
|
// Hiding a recipient who is a system contact or is someone you've
|
|
// chatted with 1:1 updates the profile whitelist, which already
|
|
// triggers a call to `updateContacts`. However, recipients who
|
|
// do not fit into these categories need this other mechanism to
|
|
// trigger `updateContacts`.
|
|
self?.updateContacts()
|
|
}
|
|
)
|
|
])
|
|
}
|
|
|
|
// MARK: Observation
|
|
|
|
private let observers = NSHashTable<ContactsViewHelperObserver>.weakObjects()
|
|
|
|
public func addObserver(_ observer: ContactsViewHelperObserver) {
|
|
AssertIsOnMainThread()
|
|
observers.add(observer)
|
|
}
|
|
|
|
// MARK: Contacts Data
|
|
|
|
public private(set) var allSignalAccounts: [SignalAccount] = []
|
|
private var phoneNumberSignalAccountMap: [String: SignalAccount] = [:]
|
|
private var serviceIdSignalAccountMap: [ServiceId: SignalAccount] = [:]
|
|
|
|
public var hasUpdatedContactsAtLeastOnce: Bool {
|
|
contactsManagerImpl.hasLoadedSystemContacts
|
|
}
|
|
|
|
public func localAddress() -> SignalServiceAddress? {
|
|
owsAssertBeta(!CurrentAppContext().isNSE)
|
|
return DependenciesBridge.shared.tsAccountManager.localIdentifiersWithMaybeSneakyTransaction?.aciAddress
|
|
}
|
|
|
|
public func fetchSignalAccount(for address: SignalServiceAddress) -> SignalAccount? {
|
|
AssertIsOnMainThread()
|
|
owsAssertBeta(!CurrentAppContext().isNSE)
|
|
|
|
if let serviceId = address.serviceId, let signalAccount = serviceIdSignalAccountMap[serviceId] {
|
|
return signalAccount
|
|
}
|
|
|
|
if let phoneNumber = address.phoneNumber, let signalAccount = phoneNumberSignalAccountMap[phoneNumber] {
|
|
return signalAccount
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
public func signalAccounts(matching searchText: String, transaction tx: SDSAnyReadTransaction) -> [SignalAccount] {
|
|
owsAssertBeta(!CurrentAppContext().isNSE)
|
|
|
|
// Check for matches against "Note to Self".
|
|
var signalAccountsToSearch = allSignalAccounts
|
|
if let localAddress = localAddress() {
|
|
signalAccountsToSearch.append(SignalAccount(address: localAddress))
|
|
}
|
|
return fullTextSearcher.filterSignalAccounts(
|
|
signalAccountsToSearch,
|
|
searchText: searchText,
|
|
transaction: tx
|
|
)
|
|
}
|
|
|
|
public func signalAccounts(includingLocalUser: Bool) -> [SignalAccount] {
|
|
switch includingLocalUser {
|
|
case true:
|
|
return allSignalAccounts
|
|
|
|
case false:
|
|
let localNumber = DependenciesBridge.shared.tsAccountManager.localIdentifiersWithMaybeSneakyTransaction?.phoneNumber
|
|
return allSignalAccounts
|
|
.filter { !($0.recipientAddress.isLocalAddress || $0.contact?.hasPhoneNumber(localNumber) == true) }
|
|
}
|
|
}
|
|
|
|
private func updateContacts() {
|
|
AssertIsOnMainThread()
|
|
owsAssertDebug(!CurrentAppContext().isNSE)
|
|
|
|
let (systemContacts, signalConnections) = databaseStorage.read { tx in
|
|
// All "System Contact"s that we believe are registered.
|
|
let systemContacts = self.contactsManagerImpl.unsortedSignalAccounts(transaction: tx)
|
|
|
|
// All Signal Connections that we believe are registered. In theory, this
|
|
// should include your system contacts and the people you chat with.
|
|
let signalConnections = self.profileManagerImpl.allWhitelistedRegisteredAddresses(tx: tx)
|
|
return (systemContacts, signalConnections)
|
|
}
|
|
|
|
var signalAccounts = systemContacts
|
|
var seenAddresses = Set(signalAccounts.lazy.map { $0.recipientAddress })
|
|
for address in signalConnections {
|
|
guard seenAddresses.insert(address).inserted else {
|
|
// We prefer the copy from contactsManager which will appear first in
|
|
// accountsToProcess; don't overwrite it.
|
|
continue
|
|
}
|
|
signalAccounts.append(SignalAccount(address: address))
|
|
}
|
|
|
|
var phoneNumberMap = [String: SignalAccount]()
|
|
var serviceIdMap = [ServiceId: SignalAccount]()
|
|
|
|
for signalAccount in signalAccounts {
|
|
if let phoneNumber = signalAccount.recipientPhoneNumber {
|
|
phoneNumberMap[phoneNumber] = signalAccount
|
|
}
|
|
if let serviceId = signalAccount.recipientServiceId {
|
|
serviceIdMap[serviceId] = signalAccount
|
|
}
|
|
}
|
|
|
|
phoneNumberSignalAccountMap = phoneNumberMap
|
|
serviceIdSignalAccountMap = serviceIdMap
|
|
allSignalAccounts = contactsManagerImpl.sortSignalAccountsWithSneakyTransaction(signalAccounts)
|
|
|
|
fireDidUpdateContacts()
|
|
}
|
|
|
|
private func fireDidUpdateContacts() {
|
|
for delegate in observers.allObjects {
|
|
delegate.contactsViewHelperDidUpdateContacts()
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: UI
|
|
|
|
extension ContactsViewHelper {
|
|
|
|
public func contactViewController(
|
|
for address: SignalServiceAddress,
|
|
editImmediately: Bool,
|
|
addToExisting existingContact: CNContact? = nil,
|
|
updatedNameComponents: PersonNameComponents? = nil
|
|
) -> CNContactViewController {
|
|
|
|
AssertIsOnMainThread()
|
|
owsAssertDebug(!CurrentAppContext().isNSE)
|
|
owsAssertDebug(contactsManagerImpl.editingAuthorization == .authorized)
|
|
|
|
let signalAccount = fetchSignalAccount(for: address)
|
|
var shouldEditImmediately = editImmediately
|
|
|
|
var contactViewController: CNContactViewController?
|
|
var cnContact: CNContact?
|
|
|
|
if let existingContact {
|
|
cnContact = existingContact
|
|
|
|
// Only add recipientId as a phone number for the existing contact if its not already present.
|
|
if let phoneNumber = address.phoneNumber {
|
|
let phoneNumberExists = existingContact.phoneNumbers.contains {
|
|
phoneNumber == $0.value.stringValue
|
|
}
|
|
|
|
owsAssertBeta(!phoneNumberExists, "We currently only should the 'add to existing contact' UI for phone numbers that don't correspond to an existing user.")
|
|
|
|
if !phoneNumberExists {
|
|
var phoneNumbers = existingContact.phoneNumbers
|
|
phoneNumbers.append(CNLabeledValue(
|
|
label: CNLabelPhoneNumberMain,
|
|
value: CNPhoneNumber(stringValue: phoneNumber)
|
|
))
|
|
let updatedContact = existingContact.mutableCopy() as! CNMutableContact
|
|
updatedContact.phoneNumbers = phoneNumbers
|
|
cnContact = updatedContact
|
|
|
|
// When adding a phone number to an existing contact, immediately enter "edit" mode.
|
|
shouldEditImmediately = true
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
if cnContact == nil, let cnContactId = signalAccount?.contact?.cnContactId {
|
|
cnContact = contactsManager.cnContact(withId: cnContactId)
|
|
}
|
|
|
|
if let updatedContact = cnContact?.mutableCopy() as? CNMutableContact {
|
|
if let givenName = updatedNameComponents?.givenName {
|
|
updatedContact.givenName = givenName
|
|
}
|
|
if let familyName = updatedNameComponents?.familyName {
|
|
updatedContact.familyName = familyName
|
|
}
|
|
|
|
if shouldEditImmediately {
|
|
// Not actually a "new" contact, but this brings up the edit form rather than the "Read" form
|
|
// saving our users a tap in some cases when we already know they want to edit.
|
|
contactViewController = CNContactViewController(forNewContact: updatedContact)
|
|
|
|
// Default title is "New Contact". We could give a more descriptive title, but anything
|
|
// seems redundant - the context is sufficiently clear.
|
|
contactViewController?.title = ""
|
|
} else {
|
|
contactViewController = CNContactViewController(for: updatedContact)
|
|
}
|
|
}
|
|
|
|
if contactViewController == nil {
|
|
let newContact = CNMutableContact()
|
|
if let phoneNumber = address.phoneNumber {
|
|
newContact.phoneNumbers = [ CNLabeledValue(
|
|
label: CNLabelPhoneNumberMain,
|
|
value: CNPhoneNumber(stringValue: phoneNumber)
|
|
)]
|
|
}
|
|
|
|
databaseStorage.read { tx in
|
|
if let givenName = profileManagerImpl.givenName(for: address, transaction: tx) {
|
|
newContact.givenName = givenName
|
|
}
|
|
if let familyName = profileManagerImpl.familyName(for: address, transaction: tx) {
|
|
newContact.familyName = familyName
|
|
}
|
|
if let profileAvatar = profileManagerImpl.profileAvatar(
|
|
for: address,
|
|
downloadIfMissing: true,
|
|
authedAccount: .implicit(),
|
|
transaction: tx
|
|
) {
|
|
newContact.imageData = profileAvatar.pngData()
|
|
}
|
|
}
|
|
|
|
if let givenName = updatedNameComponents?.givenName {
|
|
newContact.givenName = givenName
|
|
}
|
|
if let familyName = updatedNameComponents?.familyName {
|
|
newContact.familyName = familyName
|
|
}
|
|
contactViewController = CNContactViewController(forNewContact: newContact)
|
|
}
|
|
|
|
contactViewController?.allowsActions = false
|
|
contactViewController?.allowsEditing = true
|
|
|
|
return contactViewController!
|
|
}
|
|
}
|
|
|
|
// MARK: Presenting Permission-Gated Views
|
|
|
|
public extension ContactsViewHelper {
|
|
|
|
private enum Constant {
|
|
static let contactsAccessNotAllowedLearnMoreURL = URL(string: "https://support.signal.org/hc/articles/360007319011#ipad_contacts")!
|
|
}
|
|
|
|
private enum Purpose {
|
|
case edit
|
|
case share
|
|
case invite
|
|
}
|
|
|
|
enum AuthorizedBehavior {
|
|
case runAction(() -> Void)
|
|
case pushViewController(on: UINavigationController, viewController: () -> UIViewController?)
|
|
|
|
}
|
|
|
|
private func perform(authorizedBehavior: AuthorizedBehavior) {
|
|
switch authorizedBehavior {
|
|
case .runAction(let authorizedBlock):
|
|
authorizedBlock()
|
|
case .pushViewController(on: let navigationController, viewController: let viewControllerBlock):
|
|
guard let contactViewController = viewControllerBlock() else {
|
|
return owsFailDebug("Missing contactViewController.")
|
|
}
|
|
navigationController.pushViewController(contactViewController, animated: true)
|
|
}
|
|
}
|
|
|
|
enum UnauthorizedBehavior {
|
|
case presentError(from: UIViewController)
|
|
}
|
|
|
|
private func performWhenDenied(unauthorizedBehavior: UnauthorizedBehavior, purpose: Purpose) {
|
|
switch unauthorizedBehavior {
|
|
case .presentError(from: let viewController):
|
|
Self.presentContactAccessDeniedAlert(from: viewController, purpose: purpose)
|
|
}
|
|
}
|
|
|
|
private func performWhenNotAllowed(unauthorizedBehavior: UnauthorizedBehavior) {
|
|
switch unauthorizedBehavior {
|
|
case .presentError(from: let viewController):
|
|
Self.presentContactAccessNotAllowedAlert(from: viewController)
|
|
}
|
|
}
|
|
|
|
func checkEditingAuthorization(authorizedBehavior: AuthorizedBehavior, unauthorizedBehavior: UnauthorizedBehavior) {
|
|
AssertIsOnMainThread()
|
|
|
|
switch contactsManagerImpl.editingAuthorization {
|
|
case .notAllowed:
|
|
performWhenNotAllowed(unauthorizedBehavior: unauthorizedBehavior)
|
|
case .denied, .restricted:
|
|
performWhenDenied(unauthorizedBehavior: unauthorizedBehavior, purpose: .edit)
|
|
case .authorized:
|
|
perform(authorizedBehavior: authorizedBehavior)
|
|
}
|
|
}
|
|
|
|
enum SharingPurpose {
|
|
case share
|
|
case invite
|
|
}
|
|
|
|
func checkSharingAuthorization(
|
|
purpose: SharingPurpose,
|
|
authorizedBehavior: AuthorizedBehavior,
|
|
unauthorizedBehavior: UnauthorizedBehavior
|
|
) {
|
|
let deniedBlock = {
|
|
let internalPurpose: Purpose
|
|
switch purpose {
|
|
case .share:
|
|
internalPurpose = .share
|
|
case .invite:
|
|
internalPurpose = .invite
|
|
}
|
|
self.performWhenDenied(unauthorizedBehavior: unauthorizedBehavior, purpose: internalPurpose)
|
|
}
|
|
|
|
switch contactsManagerImpl.sharingAuthorization {
|
|
case .notDetermined:
|
|
CNContactStore().requestAccess(for: .contacts) { granted, error in
|
|
DispatchQueue.main.async {
|
|
if granted {
|
|
self.perform(authorizedBehavior: authorizedBehavior)
|
|
} else {
|
|
deniedBlock()
|
|
}
|
|
}
|
|
}
|
|
case .authorized:
|
|
perform(authorizedBehavior: authorizedBehavior)
|
|
case .denied:
|
|
deniedBlock()
|
|
}
|
|
}
|
|
|
|
private static func presentContactAccessDeniedAlert(from viewController: UIViewController, purpose: Purpose) {
|
|
owsAssertDebug(!CurrentAppContext().isNSE)
|
|
|
|
let title: String
|
|
let message: String
|
|
|
|
switch purpose {
|
|
case .edit:
|
|
title = OWSLocalizedString(
|
|
"EDIT_CONTACT_WITHOUT_CONTACTS_PERMISSION_ALERT_TITLE",
|
|
comment: "Alert title for when the user has just tried to edit a contacts after declining to give Signal contacts permissions"
|
|
)
|
|
message = OWSLocalizedString(
|
|
"EDIT_CONTACT_WITHOUT_CONTACTS_PERMISSION_ALERT_BODY",
|
|
comment: "Alert body for when the user has just tried to edit a contacts after declining to give Signal contacts permissions"
|
|
)
|
|
|
|
case .share:
|
|
title = OWSLocalizedString(
|
|
"CONTACT_SHARING_NO_ACCESS_TITLE",
|
|
comment: "Alert title when contacts disabled while trying to share a contact."
|
|
)
|
|
message = OWSLocalizedString(
|
|
"CONTACT_SHARING_NO_ACCESS_BODY",
|
|
comment: "Alert body when contacts disabled while trying to share a contact."
|
|
)
|
|
|
|
case .invite:
|
|
title = OWSLocalizedString(
|
|
"INVITE_FLOW_REQUIRES_CONTACT_ACCESS_TITLE",
|
|
comment: "Alert title when contacts disabled while trying to invite contacts to signal"
|
|
)
|
|
message = OWSLocalizedString(
|
|
"INVITE_FLOW_REQUIRES_CONTACT_ACCESS_BODY",
|
|
comment: "Alert body when contacts disabled while trying to invite contacts to signal"
|
|
)
|
|
}
|
|
|
|
let actionSheet = ActionSheetController(title: title, message: message)
|
|
|
|
actionSheet.addAction(ActionSheetAction(
|
|
title: OWSLocalizedString(
|
|
"AB_PERMISSION_MISSING_ACTION_NOT_NOW",
|
|
comment: "Button text to dismiss missing contacts permission alert"
|
|
),
|
|
accessibilityIdentifier: UIView.accessibilityIdentifier(containerName: "ContactAccess", name: "not_now"),
|
|
style: .cancel
|
|
))
|
|
|
|
if let openSystemSettingsAction = AppContextUtils.openSystemSettingsAction(completion: nil) {
|
|
actionSheet.addAction(openSystemSettingsAction)
|
|
}
|
|
|
|
viewController.presentActionSheet(actionSheet)
|
|
}
|
|
|
|
private static func presentContactAccessNotAllowedAlert(from viewController: UIViewController) {
|
|
let actionSheet = ActionSheetController(
|
|
message: OWSLocalizedString(
|
|
"LINKED_DEVICE_CONTACTS_NOT_ALLOWED",
|
|
comment: "Shown in an alert when trying to edit a contact."
|
|
)
|
|
)
|
|
|
|
actionSheet.addAction(ActionSheetAction(title: CommonStrings.learnMore) { [weak viewController] _ in
|
|
guard let viewController else { return }
|
|
presentContactAccessNotAllowedLearnMore(from: viewController)
|
|
})
|
|
|
|
actionSheet.addAction(ActionSheetAction(title: CommonStrings.okButton, style: .cancel))
|
|
|
|
viewController.presentActionSheet(actionSheet)
|
|
}
|
|
|
|
static func presentContactAccessNotAllowedLearnMore(from viewController: UIViewController) {
|
|
viewController.present(
|
|
SFSafariViewController(url: Constant.contactsAccessNotAllowedLearnMoreURL),
|
|
animated: true
|
|
)
|
|
}
|
|
}
|