mirror of
https://gitlab.opencode.de/bwi/bundesmessenger/clients/bundesmessenger-ios.git
synced 2026-04-16 06:28:27 +02:00
1491 lines
61 KiB
Swift
1491 lines
61 KiB
Swift
//
|
|
// Copyright 2022 New Vector Ltd
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
//
|
|
|
|
// swiftlint:disable file_length
|
|
|
|
import UIKit
|
|
import SwiftUI
|
|
import Reusable
|
|
|
|
protocol AllChatsViewControllerDelegate: AnyObject {
|
|
func allChatsViewControllerDidCompleteAuthentication(_ allChatsViewController: AllChatsViewController)
|
|
func allChatsViewController(_ allChatsViewController: AllChatsViewController, didSelectRoomWithParameters roomNavigationParameters: RoomNavigationParameters, completion: @escaping () -> Void)
|
|
func allChatsViewController(_ allChatsViewController: AllChatsViewController, didSelectRoomPreviewWithParameters roomPreviewNavigationParameters: RoomPreviewNavigationParameters, completion: (() -> Void)?)
|
|
func allChatsViewController(_ allChatsViewController: AllChatsViewController, didSelectContact contact: MXKContact, with presentationParameters: ScreenPresentationParameters)
|
|
}
|
|
|
|
class AllChatsViewController: HomeViewController {
|
|
// MARK: - Class methods
|
|
|
|
static override func nib() -> UINib! {
|
|
return UINib(nibName: String(describing: self), bundle: Bundle(for: self.classForCoder()))
|
|
}
|
|
|
|
static override func instantiate() -> Self {
|
|
let storyboard = UIStoryboard(name: "Main", bundle: .main)
|
|
guard let viewController = storyboard.instantiateViewController(withIdentifier: "AllChatsViewController") as? Self else {
|
|
fatalError("No view controller of type \(self) in the main storyboard")
|
|
}
|
|
return viewController
|
|
}
|
|
|
|
// MARK: - Properties
|
|
|
|
weak var allChatsDelegate: AllChatsViewControllerDelegate?
|
|
|
|
// MARK: - Private
|
|
|
|
private let searchController = UISearchController(searchResultsController: nil)
|
|
|
|
private let spaceActionProvider = AllChatsSpaceActionProvider()
|
|
|
|
private let editActionProvider = AllChatsEditActionProvider()
|
|
|
|
private var spaceSelectorBridgePresenter: SpaceSelectorBottomSheetCoordinatorBridgePresenter?
|
|
|
|
private var childCoordinators: [Coordinator] = []
|
|
|
|
private let tableViewPaginationThrottler = MXThrottler(minimumDelay: 0.1)
|
|
|
|
private let reviewSessionAlertSnoozeController = ReviewSessionAlertSnoozeController()
|
|
|
|
// bwi: new feature banner height
|
|
private var featureBannerViewHeight: CGFloat = 0
|
|
|
|
// bwi: application privacy modal for matomo consent
|
|
private var navigationBar: UINavigationController?
|
|
private var showMatomoConsentAlertOnCloseModal: Bool = false
|
|
|
|
private var bannerView: UIView? {
|
|
didSet {
|
|
bannerView?.translatesAutoresizingMaskIntoConstraints = false
|
|
set(tableHeadeView: bannerView)
|
|
}
|
|
}
|
|
|
|
private var isOnboardingCoordinatorPreparing: Bool = false
|
|
|
|
// bwi: 4807
|
|
private var floatingButton: UIButton?
|
|
|
|
private var theme: Theme {
|
|
ThemeService.shared().theme
|
|
}
|
|
|
|
@IBOutlet private var toolbar: UIToolbar!
|
|
private var isToolbarHidden: Bool = false {
|
|
didSet {
|
|
if isViewLoaded {
|
|
toolbar.transform = isToolbarHidden ? CGAffineTransform(translationX: 0, y: 2 * toolbarHeight) : .identity
|
|
self.view.layoutIfNeeded()
|
|
}
|
|
}
|
|
}
|
|
|
|
private func setToolbarHidden(_ isHidden: Bool, animated: Bool) {
|
|
if BWIBuildSettings.shared.enableAllChatsToolbar {
|
|
UIView.animate(withDuration: animated ? 0.3 : 0) {
|
|
self.isToolbarHidden = isHidden
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - SplitViewMasterViewControllerProtocol
|
|
|
|
// References on the currently selected room
|
|
private(set) var selectedRoomId: String?
|
|
private(set) var selectedEventId: String?
|
|
private(set) var selectedRoomSession: MXSession?
|
|
private(set) var selectedRoomPreviewData: RoomPreviewData?
|
|
|
|
// References on the currently selected contact
|
|
private(set) var selectedContact: MXKContact?
|
|
|
|
// Reference to the current onboarding flow. It is always nil unless the flow is being presented.
|
|
private(set) var onboardingCoordinatorBridgePresenter: OnboardingCoordinatorBridgePresenter?
|
|
|
|
// Tell whether the onboarding screen is preparing.
|
|
private(set) var isOnboardingInProgress: Bool = false
|
|
|
|
private var toolbarHeight: CGFloat = 0
|
|
|
|
private weak var roomFilterButton: UIButton?
|
|
|
|
// MARK: - Lifecycle
|
|
|
|
override func viewDidLoad() {
|
|
super.viewDidLoad()
|
|
|
|
editActionProvider.delegate = self
|
|
spaceActionProvider.delegate = self
|
|
|
|
recentsTableView.tag = RecentsDataSourceMode.allChats.rawValue
|
|
recentsTableView.clipsToBounds = false
|
|
recentsTableView.register(RecentEmptySectionTableViewCell.nib, forCellReuseIdentifier: RecentEmptySectionTableViewCell.reuseIdentifier)
|
|
recentsTableView.register(RecentEmptySpaceSectionTableViewCell.nib, forCellReuseIdentifier: RecentEmptySpaceSectionTableViewCell.reuseIdentifier)
|
|
recentsTableView.register(RecentsInvitesTableViewCell.nib, forCellReuseIdentifier: RecentsInvitesTableViewCell.reuseIdentifier)
|
|
recentsTableView.register(FeatureBannerViewCell<FeatureBannerView>.self, forCellReuseIdentifier: "featureBanner")
|
|
recentsTableView.contentInsetAdjustmentBehavior = .automatic
|
|
|
|
toolbarHeight = toolbar.frame.height
|
|
emptyViewBottomAnchor = toolbar.topAnchor
|
|
|
|
if BWIBuildSettings.shared.useNewBumColors { // bwi: #4883
|
|
toolbar.tintColor = ThemeService.shared().theme.tintColor
|
|
toolbar.barTintColor = ThemeService.shared().theme.backgroundColor
|
|
} else {
|
|
toolbar.tintColor = theme.colors.accent
|
|
}
|
|
|
|
// bwi: 4807 - hide the toolbar and show a floating button for room create instead
|
|
if !BWIBuildSettings.shared.enableAllChatsToolbar {
|
|
// no toolbar then use a floating button instead
|
|
floatingButton = UIButton(frame: CGRect(x: 0, y: 0, width: 56, height: 56))
|
|
updateFloatingButton()
|
|
if let floatingButton = floatingButton {
|
|
view.addSubview(floatingButton)
|
|
}
|
|
|
|
// set constraint to make the floating button stay in the lower right corner
|
|
floatingButton?.translatesAutoresizingMaskIntoConstraints = false
|
|
floatingButton?.widthAnchor.constraint(equalToConstant: 56).isActive = true
|
|
floatingButton?.heightAnchor.constraint(equalToConstant: 56).isActive = true
|
|
floatingButton?.trailingAnchor.constraint(equalTo: self.view.trailingAnchor, constant: -16).isActive = true
|
|
floatingButton?.bottomAnchor.constraint(equalTo: self.view.bottomAnchor, constant: -40).isActive = true
|
|
}
|
|
|
|
if BWIBuildSettings.shared.roomFiltersToggle {
|
|
updateNewFilterSearchAndToggleButton()
|
|
}
|
|
|
|
updateUI()
|
|
|
|
navigationItem.largeTitleDisplayMode = .never
|
|
navigationController?.navigationBar.prefersLargeTitles = false
|
|
|
|
if !BWIBuildSettings.shared.roomFiltersToggle {
|
|
searchController.obscuresBackgroundDuringPresentation = false
|
|
searchController.searchResultsUpdater = self
|
|
searchController.delegate = self
|
|
}
|
|
|
|
NotificationCenter.default.addObserver(self, selector: #selector(self.setupEditOptions), name: AllChatsLayoutSettingsManager.didUpdateSettings, object: nil)
|
|
NotificationCenter.default.addObserver(self, selector: #selector(self.updateBadgeButton), name: MXSpaceNotificationCounter.didUpdateNotificationCount, object: nil)
|
|
|
|
// bwi: 4769
|
|
self.registerThemeServiceDidChangeThemeNotification()
|
|
}
|
|
|
|
// bwi: 4806
|
|
private func updateNewFilterSearchAndToggleButton() {
|
|
let customHeaderView = UIView(frame: CGRect(x: 0, y: 0, width: recentsTableView.frame.width, height: 50))
|
|
let searchBar = UISearchBar(frame: CGRect(x: 8, y: 0, width: customHeaderView.frame.width - 48, height: 50))
|
|
let button = UIButton(frame: CGRect(x: customHeaderView.frame.width - 48 + 8, y: 0, width: 40, height: 50))
|
|
|
|
if ThemeService.shared().isCurrentThemeDark() {
|
|
button.setImage(Asset.Images.roomFilterToggleDarkOff.image, for: .normal)
|
|
button.setImage(Asset.Images.roomFilterToggleDarkOn.image, for: .selected)
|
|
} else {
|
|
button.setImage(Asset.Images.roomFilterToggleLightOff.image, for: .normal)
|
|
button.setImage(Asset.Images.roomFilterToggleLightOn.image, for: .selected)
|
|
}
|
|
let settings = AllChatsLayoutSettingsManager.shared.allChatLayoutSettings
|
|
let areFiltersVisible = !settings.filters.isEmpty
|
|
button.isSelected = !AllChatsLayoutSettingsManager.shared.allChatLayoutSettings.filters.isEmpty
|
|
button.addTarget(self, action: #selector(onFilterToggleTapped), for: .touchUpInside)
|
|
|
|
roomFilterButton = button // keep a reference to handle theme changes
|
|
|
|
searchBar.placeholder = BWIL10n.allChatsSearchbarPrompt
|
|
searchBar.backgroundImage = UIImage() // this hides the separator lines above and below
|
|
searchBar.delegate = self
|
|
|
|
customHeaderView.addSubview(searchBar)
|
|
customHeaderView.addSubview(button)
|
|
|
|
recentsTableView.tableHeaderView = customHeaderView
|
|
|
|
// set some constraints for landscape and iPad
|
|
customHeaderView.translatesAutoresizingMaskIntoConstraints = false
|
|
let constraints = [
|
|
searchBar.leadingAnchor.constraint(equalTo: customHeaderView.leadingAnchor),
|
|
searchBar.centerYAnchor.constraint(equalTo: button.centerYAnchor),
|
|
searchBar.widthAnchor.constraint(equalToConstant: 40),
|
|
searchBar.heightAnchor.constraint(equalToConstant: 40),
|
|
button.leadingAnchor.constraint(equalTo: searchBar.trailingAnchor),
|
|
button.trailingAnchor.constraint(equalTo: customHeaderView.trailingAnchor),
|
|
button.topAnchor.constraint(equalTo: customHeaderView.topAnchor),
|
|
button.bottomAnchor.constraint(equalTo: customHeaderView.bottomAnchor),
|
|
customHeaderView.centerXAnchor.constraint(equalTo: recentsTableView.centerXAnchor),
|
|
customHeaderView.widthAnchor.constraint(equalTo: recentsTableView.widthAnchor),
|
|
customHeaderView.topAnchor.constraint(equalTo: recentsTableView.topAnchor)
|
|
]
|
|
NSLayoutConstraint.activate(constraints)
|
|
}
|
|
|
|
@objc
|
|
func onSearchTextChanged(searchBar: UISearchBar) {
|
|
guard let searchText = searchBar.text, !searchText.isEmpty else {
|
|
self.dataSource?.search(withPatterns: nil)
|
|
return
|
|
}
|
|
|
|
self.dataSource?.search(withPatterns: [searchText])
|
|
}
|
|
|
|
@objc
|
|
func onFilterToggleTapped() {
|
|
let settings = AllChatsLayoutSettingsManager.shared.allChatLayoutSettings
|
|
let areFiltersVisible = !settings.filters.isEmpty
|
|
let newSettings = AllChatsLayoutSettings(sections: settings.sections,
|
|
filters: areFiltersVisible ? [] : [.unreads, .favourites, .people],
|
|
sorting: settings.sorting)
|
|
AllChatsLayoutSettingsManager.shared.allChatLayoutSettings = newSettings
|
|
Analytics.shared.trackInteraction(areFiltersVisible ? .allChatsFiltersDisabled : .allChatsFiltersEnabled)
|
|
|
|
roomFilterButton?.isSelected = !AllChatsLayoutSettingsManager.shared.allChatLayoutSettings.filters.isEmpty
|
|
}
|
|
|
|
override func viewWillAppear(_ animated: Bool) {
|
|
super.viewWillAppear(animated)
|
|
|
|
// bwi: 4769
|
|
if BWIBuildSettings.shared.useNewBumColors {
|
|
self.toolbar.tintColor = theme.tintColor
|
|
self.toolbar.barTintColor = theme.backgroundColor
|
|
} else {
|
|
self.toolbar.tintColor = theme.colors.accent
|
|
}
|
|
|
|
// bwi: 4807 - hide the toolbar and show a floating button for room create instead
|
|
if !BWIBuildSettings.shared.enableAllChatsToolbar {
|
|
toolbar.transform = CGAffineTransform(translationX: 0, y: 2 * toolbarHeight)
|
|
self.view.layoutIfNeeded()
|
|
}
|
|
|
|
if BWIBuildSettings.shared.roomFiltersToggle {
|
|
if ThemeService.shared().isCurrentThemeDark() {
|
|
roomFilterButton?.setImage(Asset.Images.roomFilterToggleDarkOff.image, for: .normal)
|
|
roomFilterButton?.setImage(Asset.Images.roomFilterToggleDarkOn.image, for: .selected)
|
|
} else {
|
|
roomFilterButton?.setImage(Asset.Images.roomFilterToggleLightOff.image, for: .normal)
|
|
roomFilterButton?.setImage(Asset.Images.roomFilterToggleLightOn.image, for: .selected)
|
|
}
|
|
} else {
|
|
if self.navigationItem.searchController == nil {
|
|
self.navigationItem.searchController = searchController
|
|
}
|
|
}
|
|
|
|
NotificationCenter.default.addObserver(self, selector: #selector(self.spaceListDidChange), name: MXSpaceService.didInitialise, object: nil)
|
|
NotificationCenter.default.addObserver(self, selector: #selector(self.spaceListDidChange), name: MXSpaceService.didBuildSpaceGraph, object: nil)
|
|
|
|
set(tableHeadeView: self.bannerView)
|
|
}
|
|
|
|
override func viewDidAppear(_ animated: Bool) {
|
|
super.viewDidAppear(animated)
|
|
|
|
// Check whether we're not logged in
|
|
let authIsShown: Bool
|
|
|
|
// bwi: (#4394) handling of the case of canceled login during pincode stage.
|
|
if MXKAccountManager.shared().accounts.isEmpty || !PinCodePreferences.shared.isPinSet && PinCodePreferences.shared.forcePinProtection {
|
|
showOnboardingFlow()
|
|
authIsShown = true
|
|
} else {
|
|
// Display a login screen if the account is soft logout
|
|
// Note: We support only one account
|
|
if let account = MXKAccountManager.shared().accounts.first, account.isSoftLogout {
|
|
showSoftLogoutOnboardingFlow(with: account.mxCredentials)
|
|
authIsShown = true
|
|
} else {
|
|
authIsShown = false
|
|
}
|
|
}
|
|
|
|
guard !authIsShown else {
|
|
return
|
|
}
|
|
|
|
AppDelegate.theDelegate().checkAppVersion()
|
|
}
|
|
|
|
func presentFederationIntroductionSheet() {
|
|
guard BWIBuildSettings.shared.showFederationIntroduction else {
|
|
return
|
|
}
|
|
|
|
guard BWIBuildSettings.shared.isFederationEnabled else {
|
|
return
|
|
}
|
|
|
|
guard self.mainSession.homeserverWellknown.shouldShowFederationIntroduction() else {
|
|
return
|
|
}
|
|
|
|
let notificationService = BWIAccountNotificationService(mxSession: self.mainSession)
|
|
guard notificationService.showFederationIntroductionFlag() else {
|
|
return
|
|
}
|
|
|
|
let viewController = UIHostingController(rootView: IntroduceFederationView().environmentObject(BWIThemeService.shared))
|
|
viewController.isModalInPresentation = true
|
|
present(viewController, animated: true) {
|
|
notificationService.setShowFederationIntroductionFlag(false)
|
|
}
|
|
}
|
|
|
|
override func viewWillTransition(to size: CGSize, with coordinator: UIViewControllerTransitionCoordinator) {
|
|
super.viewWillTransition(to: size, with: coordinator)
|
|
|
|
coordinator.animate { context in
|
|
self.recentsTableView?.tableHeaderView?.layoutIfNeeded()
|
|
// self.recentsTableView?.tableHeaderView = self.recentsTableView?.tableHeaderView
|
|
}
|
|
}
|
|
|
|
// bwi: 4769
|
|
private func registerThemeServiceDidChangeThemeNotification() {
|
|
NotificationCenter.default.addObserver(self, selector: #selector(themeDidChange), name: .themeServiceDidChangeTheme, object: nil)
|
|
}
|
|
|
|
// bwi: 4769
|
|
@objc private func themeDidChange() {
|
|
self.update(with: ThemeService.shared().theme)
|
|
}
|
|
|
|
|
|
// MARK: - Public
|
|
|
|
func switchSpace(withId spaceId: String?) {
|
|
searchController.isActive = false
|
|
|
|
guard let spaceId = spaceId else {
|
|
dataSource?.currentSpace = nil
|
|
updateUI()
|
|
|
|
return
|
|
}
|
|
|
|
guard let space = self.mainSession.spaceService.getSpace(withId: spaceId) else {
|
|
MXLog.warning("[AllChatsViewController] switchSpace: no space found with id \(spaceId)")
|
|
return
|
|
}
|
|
|
|
dataSource?.currentSpace = space
|
|
updateUI()
|
|
|
|
self.recentsTableView.scrollToRow(at: IndexPath(row: 0, section: 0), at: .top, animated: true)
|
|
}
|
|
|
|
override var recentsDataSourceMode: RecentsDataSourceMode {
|
|
.allChats
|
|
}
|
|
|
|
override func addMatrixSession(_ mxSession: MXSession!) {
|
|
super.addMatrixSession(mxSession)
|
|
|
|
if let dataSource = dataSource, !dataSource.mxSessions.contains(where: { $0 as? MXSession == mxSession }) {
|
|
dataSource.addMatrixSession(mxSession)
|
|
// Setting the delegate is required to send a RecentsViewControllerDataReadyNotification.
|
|
// Without this, when clearing the cache we end up with an infinite green spinner.
|
|
(dataSource as? RecentsDataSource)?.setDelegate(self, andRecentsDataSourceMode: recentsDataSourceMode)
|
|
} else {
|
|
initDataSource()
|
|
}
|
|
}
|
|
|
|
override func removeMatrixSession(_ mxSession: MXSession!) {
|
|
super.removeMatrixSession(mxSession)
|
|
|
|
guard let dataSource = dataSource else { return }
|
|
dataSource.removeMatrixSession(mxSession)
|
|
|
|
if dataSource.mxSessions.isEmpty {
|
|
// The user logged out -> we need to reset the data source
|
|
displayList(nil)
|
|
}
|
|
}
|
|
|
|
private func initDataSource() {
|
|
guard self.dataSource == nil, let mainSession = self.mxSessions.first as? MXSession else {
|
|
return
|
|
}
|
|
|
|
MXLog.debug("[AllChatsViewController] initDataSource")
|
|
let recentsListService = RecentsListService(withSession: mainSession)
|
|
let recentsDataSource = RecentsDataSource(matrixSession: mainSession, recentsListService: recentsListService)
|
|
displayList(recentsDataSource)
|
|
recentsDataSource?.setDelegate(self, andRecentsDataSourceMode: self.recentsDataSourceMode)
|
|
}
|
|
|
|
@objc private func spaceListDidChange() {
|
|
guard self.editActionProvider.shouldUpdate(with: self.mainSession, parentSpace: self.dataSource?.currentSpace) else {
|
|
return
|
|
}
|
|
|
|
updateUI()
|
|
}
|
|
|
|
@objc private func addFabButton() {
|
|
// Nothing to do. We don't need FAB
|
|
}
|
|
|
|
@objc private func sections() -> Array<Int> {
|
|
return [
|
|
RecentsDataSourceSectionType.directory.rawValue,
|
|
RecentsDataSourceSectionType.invites.rawValue,
|
|
RecentsDataSourceSectionType.favorites.rawValue,
|
|
RecentsDataSourceSectionType.people.rawValue,
|
|
RecentsDataSourceSectionType.allChats.rawValue,
|
|
RecentsDataSourceSectionType.lowPriority.rawValue,
|
|
RecentsDataSourceSectionType.serverNotice.rawValue,
|
|
RecentsDataSourceSectionType.suggestedRooms.rawValue,
|
|
RecentsDataSourceSectionType.breadcrumbs.rawValue,
|
|
RecentsDataSourceSectionType.featureBanner.rawValue
|
|
]
|
|
}
|
|
|
|
override func startActivityIndicator() {
|
|
super.startActivityIndicator()
|
|
}
|
|
|
|
// bwi: show alert again when modal is dismissed (button press)
|
|
@objc func bwiCloseModal() {
|
|
showMatomoConsentAlertOnCloseModal = false
|
|
navigationBar?.dismiss(animated: true)
|
|
bwiPresentMatomoConsentAlert()
|
|
}
|
|
|
|
func bwiPresentMatomoConsentAlert() {
|
|
let alert = UIAlertController(title: BWIL10n.bwiAnalyticsAlertTitle,
|
|
message: BWIL10n.bwiAnalyticsAlertBody(AppInfo.current.displayName),
|
|
preferredStyle: .alert)
|
|
|
|
alert.addAction(UIAlertAction(title: BWIL10n.bwiAnalyticsAlertInfoButton,
|
|
style: .default,
|
|
handler: { [self] action in
|
|
if let defaultURL = URL(string: BWIBuildSettings.shared.applicationPrivacyPolicyWithMatomoSectionUrlString) {
|
|
if BWIBuildSettings.shared.bwiUseWellKnownPrivacyPolicyLink {
|
|
guard let wellKnownDataPrivacyURL = URL(string: self.mainSession.homeserverWellknown.dataPrivacyURL() ?? ""), let defaultHost = defaultURL.host else {
|
|
UIApplication.shared.open(defaultURL)
|
|
return
|
|
}
|
|
if !wellKnownDataPrivacyURL.absoluteString.contains(defaultHost) {
|
|
UIApplication.shared.open(wellKnownDataPrivacyURL)
|
|
} else {
|
|
UIApplication.shared.open(defaultURL)
|
|
}
|
|
} else {
|
|
UIApplication.shared.open(defaultURL)
|
|
}
|
|
}
|
|
showMatomoConsentAlertOnCloseModal = true
|
|
}))
|
|
|
|
alert.addAction(UIAlertAction(title: BWIL10n.bwiAnalyticsAlertCancelButton,
|
|
style: .default,
|
|
handler: { action in
|
|
BWIAnalytics.sharedTracker.running = false
|
|
// bwi: 5706 show federation announcement promt
|
|
self.bwiCheckForFederationAnnouncementPromt()
|
|
// bwi: 5660 introduce federation
|
|
self.presentFederationIntroductionSheet()
|
|
}))
|
|
|
|
alert.addAction(UIAlertAction(title: BWIL10n.bwiAnalyticsAlertOkButton,
|
|
style: .cancel,
|
|
handler: { action in
|
|
BWIAnalytics.sharedTracker.running = true
|
|
BWIAnalytics.sharedTracker.trackBwiValue(0, "General", "ConsentGiven", "popup")
|
|
// bwi: 5706 show federation announcement promt
|
|
self.bwiCheckForFederationAnnouncementPromt()
|
|
// bwi: 5660 introduce federation
|
|
self.presentFederationIntroductionSheet()
|
|
}))
|
|
|
|
self.present(alert, animated: true)
|
|
}
|
|
|
|
// bwi: 5706 show federation announcement promt
|
|
func bwiCheckForFederationAnnouncementPromt() {
|
|
guard self.mainSession.homeserverWellknown.shouldShowFederationAnnouncement() else {
|
|
return
|
|
}
|
|
|
|
let notificationService = BWIAccountNotificationService(mxSession: self.mainSession)
|
|
guard notificationService.showFederationAnnouncementFlag() else {
|
|
return
|
|
}
|
|
|
|
let viewController = UIHostingController(rootView: FederationAnnouncementView().environmentObject(BWIThemeService.shared))
|
|
viewController.isModalInPresentation = true
|
|
viewController.modalPresentationStyle = .formSheet
|
|
present(viewController, animated: true) {
|
|
notificationService.setShowFederationAnnouncementFlag(false)
|
|
}
|
|
}
|
|
|
|
// MARK: - Actions
|
|
|
|
@objc private func showSpaceSelectorAction(sender: AnyObject) {
|
|
Analytics.shared.viewRoomTrigger = .roomList
|
|
let currentSpaceId = dataSource?.currentSpace?.spaceId ?? SpaceSelectorConstants.homeSpaceId
|
|
let spaceSelectorBridgePresenter = SpaceSelectorBottomSheetCoordinatorBridgePresenter(session: self.mainSession, selectedSpaceId: currentSpaceId, showHomeSpace: true)
|
|
spaceSelectorBridgePresenter.present(from: self, animated: true)
|
|
spaceSelectorBridgePresenter.delegate = self
|
|
self.spaceSelectorBridgePresenter = spaceSelectorBridgePresenter
|
|
}
|
|
|
|
// MARK: - UITableViewDataSource
|
|
|
|
private func sectionType(forSectionAt index: Int) -> RecentsDataSourceSectionType? {
|
|
guard let recentsDataSource = dataSource as? RecentsDataSource else {
|
|
return nil
|
|
}
|
|
|
|
return recentsDataSource.sections.sectionType(forSectionIndex: index)
|
|
}
|
|
|
|
override func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
|
|
guard let sectionType = sectionType(forSectionAt: section), sectionType == .invites else {
|
|
return super.tableView(tableView, numberOfRowsInSection: section)
|
|
}
|
|
if sectionType == .featureBanner {
|
|
return 1
|
|
}
|
|
|
|
return dataSource?.tableView(tableView, numberOfRowsInSection: section) ?? 0
|
|
}
|
|
|
|
override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
|
|
guard let sectionType = sectionType(forSectionAt: indexPath.section), sectionType == .invites || sectionType == .featureBanner else {
|
|
return super.tableView(tableView, cellForRowAt: indexPath)
|
|
}
|
|
// bwi: feature banner cell
|
|
if sectionType == .featureBanner {
|
|
guard let cell = tableView.dequeueReusableCell(withIdentifier: "featureBanner", for: indexPath) as? FeatureBannerViewCell<FeatureBannerView> else {
|
|
return UITableViewCell()
|
|
}
|
|
cell.selectionStyle = .none
|
|
cell.setupView(parent: self, rootView: FeatureBannerView(delegate: cell))
|
|
featureBannerViewHeight = cell.calculateHeight()
|
|
return cell
|
|
}
|
|
guard let dataSource = dataSource else {
|
|
MXLog.failure("Missing data source")
|
|
return UITableViewCell()
|
|
}
|
|
return dataSource.tableView(tableView, cellForRowAt: indexPath)
|
|
}
|
|
|
|
// MARK: - UITableViewDelegate
|
|
|
|
override func tableView(_ tableView: UITableView, heightForRowAt indexPath: IndexPath) -> CGFloat {
|
|
guard let sectionType = sectionType(forSectionAt: indexPath.section), sectionType == .invites || sectionType == .featureBanner else {
|
|
return super.tableView(tableView, heightForRowAt: indexPath)
|
|
}
|
|
if sectionType == .featureBanner {
|
|
return featureBannerViewHeight
|
|
} else {
|
|
return dataSource?.cellHeight(at: indexPath) ?? 0
|
|
}
|
|
}
|
|
|
|
override func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
|
|
guard let sectionType = sectionType(forSectionAt: indexPath.section), sectionType == .invites || sectionType == .featureBanner else {
|
|
super.tableView(tableView, didSelectRowAt: indexPath)
|
|
return
|
|
}
|
|
if sectionType == .invites {
|
|
showRoomInviteList()
|
|
} else {
|
|
// bwi: feature banner is not selectable
|
|
return
|
|
}
|
|
}
|
|
|
|
override func tableView(_ tableView: UITableView, willDisplay cell: UITableViewCell, forRowAt indexPath: IndexPath) {
|
|
super.tableView(tableView, willDisplay: cell, forRowAt: indexPath)
|
|
|
|
guard let recentsDataSource = dataSource as? RecentsDataSource else {
|
|
return
|
|
}
|
|
|
|
let sectionType = recentsDataSource.sections.sectionType(forSectionIndex: indexPath.section)
|
|
// We need to trottle a bit earlier so the next section is not visible even if the tableview scrolls faster
|
|
guard sectionType == .allChats, let numberOfRowsInSection = recentsDataSource.recentsListService.allChatsRoomListData?.counts.numberOfRooms, indexPath.row == numberOfRowsInSection - 4 else {
|
|
return
|
|
}
|
|
|
|
tableViewPaginationThrottler.throttle {
|
|
recentsDataSource.paginate(inSection: indexPath.section)
|
|
}
|
|
}
|
|
|
|
// MARK: - Toolbar animation
|
|
|
|
private var initialScrollPosition: Double = 0
|
|
|
|
private func scrollPosition(of scrollView: UIScrollView) -> Double {
|
|
return scrollView.contentOffset.y + scrollView.adjustedContentInset.top
|
|
}
|
|
|
|
override func scrollViewWillBeginDragging(_ scrollView: UIScrollView) {
|
|
guard scrollView == recentsTableView else {
|
|
return
|
|
}
|
|
|
|
initialScrollPosition = scrollPosition(of: scrollView)
|
|
}
|
|
|
|
override func scrollViewDidScroll(_ scrollView: UIScrollView) {
|
|
super.scrollViewDidScroll(scrollView)
|
|
|
|
guard scrollView == recentsTableView else {
|
|
return
|
|
}
|
|
|
|
let scrollPosition = scrollPosition(of: scrollView)
|
|
|
|
if !self.recentsTableView.isDragging && scrollPosition == 0 && self.isToolbarHidden == true {
|
|
self.setToolbarHidden(false, animated: true)
|
|
}
|
|
|
|
guard self.recentsTableView.isDragging else {
|
|
return
|
|
}
|
|
|
|
guard scrollPosition > 0 && scrollPosition < self.recentsTableView.contentSize.height - self.recentsTableView.bounds.height else {
|
|
return
|
|
}
|
|
|
|
let isToolBarHidden: Bool = scrollPosition - initialScrollPosition > 0
|
|
if isToolBarHidden != self.isToolbarHidden {
|
|
self.setToolbarHidden(isToolBarHidden, animated: true)
|
|
}
|
|
}
|
|
|
|
// MARK: - Empty view management
|
|
|
|
override func updateEmptyView() {
|
|
guard let mainSession = self.mainSession else {
|
|
return
|
|
}
|
|
|
|
let title: String
|
|
let informationText: String
|
|
if let currentSpace = self.dataSource?.currentSpace {
|
|
title = VectorL10n.allChatsEmptyViewTitle(currentSpace.summary?.displayName ?? VectorL10n.spaceTag)
|
|
informationText = VectorL10n.allChatsEmptySpaceInformation
|
|
} else {
|
|
let myUser = mainSession.myUser
|
|
let displayName = (myUser?.displayName ?? myUser?.userId) ?? ""
|
|
let appName = AppInfo.current.displayName
|
|
title = VectorL10n.homeEmptyViewTitle(appName, displayName)
|
|
informationText = VectorL10n.allChatsEmptyViewInformation
|
|
}
|
|
|
|
self.emptyView?.fill(with: emptyViewArtwork,
|
|
title: title,
|
|
informationText: informationText)
|
|
|
|
// BWI: #5307
|
|
if let floatingButton = floatingButton, let emptyView = self.emptyView {
|
|
if emptyView.superview != nil {
|
|
view.insertSubview(floatingButton, aboveSubview: self.emptyView)
|
|
}
|
|
}
|
|
}
|
|
|
|
private var emptyViewArtwork: UIImage {
|
|
if self.dataSource?.currentSpace == nil {
|
|
return ThemeService.shared().isCurrentThemeDark() ? Asset.Images.allChatsEmptyScreenArtworkDark.image : Asset.Images.allChatsEmptyScreenArtwork.image
|
|
} else {
|
|
return ThemeService.shared().isCurrentThemeDark() ? Asset.Images.allChatsEmptySpaceArtworkDark.image : Asset.Images.allChatsEmptySpaceArtwork.image
|
|
}
|
|
}
|
|
|
|
override func shouldShowEmptyView() -> Bool {
|
|
let shouldShowEmptyView = super.shouldShowEmptyView() && !AllChatsLayoutSettingsManager.shared.hasAnActiveFilter
|
|
|
|
if !BWIBuildSettings.shared.roomFiltersToggle {
|
|
if shouldShowEmptyView {
|
|
self.navigationItem.searchController = nil
|
|
navigationItem.largeTitleDisplayMode = .never
|
|
} else {
|
|
self.navigationItem.searchController = searchController
|
|
navigationItem.largeTitleDisplayMode = .automatic
|
|
}
|
|
}
|
|
|
|
return shouldShowEmptyView
|
|
}
|
|
|
|
|
|
// MARK: - Theme management
|
|
|
|
override func userInterfaceThemeDidChange() {
|
|
super.userInterfaceThemeDidChange()
|
|
|
|
guard self.toolbarItems != nil else {
|
|
return
|
|
}
|
|
|
|
self.update(with: theme)
|
|
}
|
|
|
|
private func update(with theme: Theme) {
|
|
// bwi: 4769
|
|
if BWIBuildSettings.shared.useNewBumColors {
|
|
toolbar.tintColor = ThemeService.shared().theme.tintColor
|
|
toolbar.barTintColor = ThemeService.shared().theme.backgroundColor
|
|
// BWI: #4966
|
|
for barButtonItem in toolbar.items ?? [UIBarButtonItem]() {
|
|
barButtonItem.tintColor = ThemeService.shared().theme.tintColor
|
|
}
|
|
|
|
UIToolbar.appearance().tintColor = ThemeService.shared().theme.tintColor
|
|
UIToolbar.appearance().barTintColor = ThemeService.shared().theme.backgroundColor
|
|
} else {
|
|
self.navigationController?.toolbar?.tintColor = theme.colors.accent
|
|
}
|
|
|
|
// bwi: 4807
|
|
updateFloatingButton()
|
|
}
|
|
|
|
private func updateFloatingButton() {
|
|
if ThemeService.shared().isCurrentThemeDark() {
|
|
floatingButton?.setImage(Asset.Images.buttonNewDark.image, for: .normal)
|
|
} else {
|
|
floatingButton?.setImage(Asset.Images.buttonNewLight.image, for: .normal)
|
|
}
|
|
}
|
|
|
|
// MARK: - Private
|
|
|
|
private func set(tableHeadeView: UIView?) {
|
|
guard let tableView = recentsTableView else {
|
|
return
|
|
}
|
|
|
|
// tableView.tableHeaderView = tableHeadeView
|
|
// tableView.tableHeaderView?.widthAnchor.constraint(equalTo: tableView.widthAnchor).isActive = true
|
|
// tableView.tableHeaderView?.layoutIfNeeded()
|
|
// tableView.tableHeaderView = self.recentsTableView?.tableHeaderView
|
|
}
|
|
|
|
@objc private func setupEditOptions() {
|
|
guard let currentSpace = self.dataSource?.currentSpace else {
|
|
updateRightNavigationItem(with: AllChatsActionProvider().menu)
|
|
return
|
|
}
|
|
|
|
updateRightNavigationItem(with: spaceActionProvider.updateMenu(with: mainSession, space: currentSpace) { [weak self] menu in
|
|
self?.updateRightNavigationItem(with: menu)
|
|
})
|
|
}
|
|
|
|
private func updateUI() {
|
|
let currentSpace = self.dataSource?.currentSpace
|
|
self.title = currentSpace?.summary?.displayName ?? VectorL10n.allChatsTitle
|
|
|
|
setupEditOptions()
|
|
|
|
let menu = editActionProvider.updateMenu(with: mainSession, parentSpace: currentSpace, completion: { [weak self] menu in
|
|
if BWIBuildSettings.shared.enableAllChatsToolbar {
|
|
self?.updateToolbar(with: menu)
|
|
} else {
|
|
}
|
|
})
|
|
|
|
if BWIBuildSettings.shared.enableAllChatsToolbar {
|
|
updateToolbar(with: menu)
|
|
} else {
|
|
updateFloatingButton()
|
|
self.floatingButton?.menu = menu
|
|
self.floatingButton?.showsMenuAsPrimaryAction = true
|
|
}
|
|
|
|
updateEmptyView()
|
|
updateBadgeButton()
|
|
}
|
|
|
|
private func updateRightNavigationItem(with menu: UIMenu) {
|
|
// bwi 4704 - hide right navigation bar button
|
|
if BWIBuildSettings.shared.showAllChatsFilterMenu {
|
|
self.navigationItem.rightBarButtonItem = UIBarButtonItem(image: UIImage(systemName: "ellipsis.circle"), menu: menu)
|
|
}
|
|
}
|
|
|
|
private lazy var spacesButton: BadgedBarButtonItem = {
|
|
let innerButton = UIButton(type: .system)
|
|
innerButton.accessibilityLabel = VectorL10n.spaceSelectorTitle
|
|
innerButton.addTarget(self, action: #selector(self.showSpaceSelectorAction(sender:)), for: .touchUpInside)
|
|
innerButton.setImage(Asset.Images.allChatsSpacesIcon.image, for: .normal)
|
|
return BadgedBarButtonItem(withBaseButton: innerButton, theme: theme)
|
|
}()
|
|
|
|
@objc private func updateBadgeButton() {
|
|
guard isViewLoaded, let session = mainSession else {
|
|
return
|
|
}
|
|
|
|
let notificationCount = session.spaceService.missedNotificationsCount
|
|
let hasSpaceInvite = session.spaceService.hasSpaceInvite
|
|
let isBadgeHighlighed = session.spaceService.hasHighlightNotification || hasSpaceInvite
|
|
let badgeValue: String
|
|
|
|
switch notificationCount {
|
|
case 0:
|
|
badgeValue = hasSpaceInvite ? "!" : "0"
|
|
case (1 ... Constants.spacesButtonMaxCount):
|
|
badgeValue = "\(notificationCount)"
|
|
default:
|
|
badgeValue = "\(Constants.spacesButtonMaxCount)+"
|
|
}
|
|
|
|
spacesButton.badgeText = badgeValue
|
|
spacesButton.badgeBackgroundColor = isBadgeHighlighed ? theme.noticeColor : theme.noticeSecondaryColor
|
|
}
|
|
|
|
private func updateToolbar(with menu: UIMenu) {
|
|
guard isViewLoaded else {
|
|
return
|
|
}
|
|
|
|
self.isToolbarHidden = false
|
|
self.update(with: theme)
|
|
|
|
// bwi: 4179
|
|
var allChatsEditButton = UIBarButtonItem(image: Asset.Images.allChatsEditIcon.image, menu: menu)
|
|
allChatsEditButton.tintColor = ThemeService.shared().theme.tintColor // bwi: #4883
|
|
|
|
if BWIBuildSettings.shared.enableSpaces {
|
|
self.toolbar.items = [
|
|
spacesButton,
|
|
UIBarButtonItem.flexibleSpace(),
|
|
allChatsEditButton
|
|
]
|
|
} else {
|
|
self.toolbar.items = [
|
|
UIBarButtonItem.flexibleSpace(),
|
|
allChatsEditButton
|
|
]
|
|
}
|
|
|
|
}
|
|
|
|
private func showCreateSpace(parentSpaceId: String?) {
|
|
let coordinator = SpaceCreationCoordinator(parameters: SpaceCreationCoordinatorParameters(session: self.mainSession, parentSpaceId: parentSpaceId))
|
|
let presentable = coordinator.toPresentable()
|
|
self.present(presentable, animated: true, completion: nil)
|
|
coordinator.callback = { [weak self] result in
|
|
guard let self = self else {
|
|
return
|
|
}
|
|
|
|
coordinator.toPresentable().dismiss(animated: true) {
|
|
self.remove(childCoordinator: coordinator)
|
|
switch result {
|
|
case .cancel:
|
|
break
|
|
case .done(let spaceId):
|
|
self.switchSpace(withId: spaceId)
|
|
}
|
|
}
|
|
}
|
|
add(childCoordinator: coordinator)
|
|
coordinator.start()
|
|
}
|
|
|
|
private func add(childCoordinator: Coordinator) {
|
|
self.childCoordinators.append(childCoordinator)
|
|
}
|
|
|
|
private func remove(childCoordinator: Coordinator) {
|
|
self.childCoordinators.append(childCoordinator)
|
|
}
|
|
|
|
private func showSpaceInvite() {
|
|
guard let session = mainSession, let spaceRoom = dataSource?.currentSpace?.room else {
|
|
return
|
|
}
|
|
|
|
let coordinator = ContactsPickerCoordinator(session: session, room: spaceRoom, initialSearchText: nil, actualParticipants: nil, invitedParticipants: nil, userParticipant: nil)
|
|
coordinator.delegate = self
|
|
coordinator.start()
|
|
add(childCoordinator: coordinator)
|
|
present(coordinator.toPresentable(), animated: true)
|
|
}
|
|
|
|
private func showSpaceMembers() {
|
|
guard let session = mainSession, let spaceId = dataSource?.currentSpace?.spaceId else {
|
|
return
|
|
}
|
|
|
|
let coordinator = SpaceMembersCoordinator(parameters: SpaceMembersCoordinatorParameters(userSessionsService: UserSessionsService.shared, session: session, spaceId: spaceId))
|
|
coordinator.delegate = self
|
|
let presentable = coordinator.toPresentable()
|
|
presentable.presentationController?.delegate = self
|
|
coordinator.start()
|
|
add(childCoordinator: coordinator)
|
|
present(presentable, animated: true, completion: nil)
|
|
}
|
|
|
|
private func showSpaceSettings() {
|
|
guard let session = mainSession, let spaceId = dataSource?.currentSpace?.spaceId else {
|
|
return
|
|
}
|
|
|
|
let coordinator = SpaceSettingsModalCoordinator(parameters: SpaceSettingsModalCoordinatorParameters(session: session, spaceId: spaceId, parentSpaceId: nil))
|
|
coordinator.callback = { [weak self] result in
|
|
guard let self = self else { return }
|
|
|
|
coordinator.toPresentable().dismiss(animated: true) {
|
|
self.remove(childCoordinator: coordinator)
|
|
}
|
|
}
|
|
|
|
let presentable = coordinator.toPresentable()
|
|
presentable.presentationController?.delegate = self
|
|
present(presentable, animated: true, completion: nil)
|
|
coordinator.start()
|
|
add(childCoordinator: coordinator)
|
|
}
|
|
|
|
private func showLeaveSpace() {
|
|
guard let session = mainSession, let spaceSummary = dataSource?.currentSpace?.summary else {
|
|
return
|
|
}
|
|
|
|
let name = spaceSummary.displayName ?? VectorL10n.spaceTag
|
|
|
|
let selectionHeader = MatrixItemChooserSelectionHeader(title: VectorL10n.leaveSpaceSelectionTitle,
|
|
selectAllTitle: VectorL10n.leaveSpaceSelectionAllRooms,
|
|
selectNoneTitle: VectorL10n.leaveSpaceSelectionNoRooms)
|
|
let paramaters = MatrixItemChooserCoordinatorParameters(session: session,
|
|
title: VectorL10n.leaveSpaceTitle(name),
|
|
detail: VectorL10n.leaveSpaceMessage(name),
|
|
selectionHeader: selectionHeader,
|
|
viewProvider: LeaveSpaceViewProvider(navTitle: nil),
|
|
itemsProcessor: LeaveSpaceItemsProcessor(spaceId: spaceSummary.roomId, session: session))
|
|
let coordinator = MatrixItemChooserCoordinator(parameters: paramaters)
|
|
coordinator.toPresentable().presentationController?.delegate = self
|
|
coordinator.start()
|
|
add(childCoordinator: coordinator)
|
|
coordinator.completion = { [weak self] result in
|
|
// switching to home space
|
|
self?.switchSpace(withId: nil)
|
|
coordinator.toPresentable().dismiss(animated: true) {
|
|
self?.remove(childCoordinator: coordinator)
|
|
}
|
|
}
|
|
present(coordinator.toPresentable(), animated: true)
|
|
}
|
|
|
|
private func showRoomInviteList() {
|
|
let invitesViewController = RoomInvitesViewController.instantiate()
|
|
invitesViewController.userIndicatorStore = self.userIndicatorStore
|
|
let recentsListService = RecentsListService(withSession: mainSession)
|
|
let recentsDataSource = RecentsDataSource(matrixSession: mainSession, recentsListService: recentsListService)
|
|
invitesViewController.displayList(recentsDataSource)
|
|
self.navigationController?.pushViewController(invitesViewController, animated: true)
|
|
}
|
|
|
|
}
|
|
|
|
private extension AllChatsViewController {
|
|
enum Constants {
|
|
static let spacesButtonMaxCount: UInt = 999
|
|
}
|
|
}
|
|
|
|
// MARK: - SpaceSelectorBottomSheetCoordinatorBridgePresenterDelegate
|
|
extension AllChatsViewController: SpaceSelectorBottomSheetCoordinatorBridgePresenterDelegate {
|
|
|
|
func spaceSelectorBottomSheetCoordinatorBridgePresenterDidCancel(_ coordinatorBridgePresenter: SpaceSelectorBottomSheetCoordinatorBridgePresenter) {
|
|
coordinatorBridgePresenter.dismiss(animated: true) {
|
|
self.spaceSelectorBridgePresenter = nil
|
|
}
|
|
}
|
|
|
|
func spaceSelectorBottomSheetCoordinatorBridgePresenterDidSelectHome(_ coordinatorBridgePresenter: SpaceSelectorBottomSheetCoordinatorBridgePresenter) {
|
|
coordinatorBridgePresenter.dismiss(animated: true) {
|
|
self.spaceSelectorBridgePresenter = nil
|
|
}
|
|
|
|
switchSpace(withId: nil)
|
|
}
|
|
|
|
func spaceSelectorBottomSheetCoordinatorBridgePresenter(_ coordinatorBridgePresenter: SpaceSelectorBottomSheetCoordinatorBridgePresenter, didSelectSpaceWithId spaceId: String) {
|
|
coordinatorBridgePresenter.dismiss(animated: true) {
|
|
self.spaceSelectorBridgePresenter = nil
|
|
}
|
|
|
|
switchSpace(withId: spaceId)
|
|
}
|
|
|
|
func spaceSelectorBottomSheetCoordinatorBridgePresenter(_ coordinatorBridgePresenter: SpaceSelectorBottomSheetCoordinatorBridgePresenter, didCreateSpaceWithinSpaceWithId parentSpaceId: String?) {
|
|
coordinatorBridgePresenter.dismiss(animated: true) {
|
|
self.spaceSelectorBridgePresenter = nil
|
|
}
|
|
self.showCreateSpace(parentSpaceId: parentSpaceId)
|
|
}
|
|
|
|
}
|
|
|
|
// MARK: - UISearchResultsUpdating
|
|
extension AllChatsViewController: UISearchResultsUpdating {
|
|
func updateSearchResults(for searchController: UISearchController) {
|
|
guard let searchText = searchController.searchBar.text, !searchText.isEmpty else {
|
|
self.dataSource?.search(withPatterns: nil)
|
|
return
|
|
}
|
|
|
|
self.dataSource?.search(withPatterns: [searchText])
|
|
}
|
|
}
|
|
|
|
// MARK: - UISearchControllerDelegate
|
|
extension AllChatsViewController: UISearchControllerDelegate {
|
|
func willPresentSearchController(_ searchController: UISearchController) {
|
|
// Fix for https://github.com/vector-im/element-ios/issues/6680
|
|
self.recentsTableView.scrollToRow(at: IndexPath(row: 0, section: 0), at: .top, animated: true)
|
|
}
|
|
}
|
|
|
|
extension AllChatsViewController {
|
|
override func searchBar(_ searchBar: UISearchBar, textDidChange: String) {
|
|
guard let searchText = searchBar.text, !searchText.isEmpty else {
|
|
self.dataSource?.search(withPatterns: nil)
|
|
return
|
|
}
|
|
|
|
self.dataSource?.search(withPatterns: [searchText])
|
|
}
|
|
}
|
|
|
|
// MARK: - UIAdaptivePresentationControllerDelegate
|
|
extension AllChatsViewController: UIAdaptivePresentationControllerDelegate {
|
|
|
|
func presentationControllerDidDismiss(_ presentationController: UIPresentationController) {
|
|
// bwi: show matomo consent alert again
|
|
if showMatomoConsentAlertOnCloseModal {
|
|
showMatomoConsentAlertOnCloseModal = false
|
|
bwiPresentMatomoConsentAlert()
|
|
}
|
|
guard let coordinator = childCoordinators.last else {
|
|
return
|
|
}
|
|
|
|
remove(childCoordinator: coordinator)
|
|
}
|
|
}
|
|
|
|
// MARK: - AllChatsEditActionProviderDelegate
|
|
extension AllChatsViewController: AllChatsEditActionProviderDelegate {
|
|
|
|
func allChatsEditActionProvider(_ actionProvider: AllChatsEditActionProvider, didSelect option: AllChatsEditActionProviderOption) {
|
|
switch option {
|
|
case .exploreRooms:
|
|
joinARoom()
|
|
case .createRoom:
|
|
createNewRoom()
|
|
case .startChat:
|
|
startChat()
|
|
case .createSpace:
|
|
showCreateSpace(parentSpaceId: dataSource?.currentSpace?.spaceId)
|
|
case .scanPermalink:
|
|
scanPermalink()
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// MARK: - AllChatsSpaceActionProviderDelegate
|
|
extension AllChatsViewController: AllChatsSpaceActionProviderDelegate {
|
|
func allChatsSpaceActionProvider(_ actionProvider: AllChatsSpaceActionProvider, didSelect option: AllChatsSpaceActionProviderOption) {
|
|
switch option {
|
|
case .invitePeople:
|
|
showSpaceInvite()
|
|
case .spaceMembers:
|
|
showSpaceMembers()
|
|
case .spaceSettings:
|
|
showSpaceSettings()
|
|
case .leaveSpace:
|
|
showLeaveSpace()
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - ContactsPickerCoordinatorDelegate
|
|
extension AllChatsViewController: ContactsPickerCoordinatorDelegate {
|
|
|
|
func contactsPickerCoordinatorDidStartLoading(_ coordinator: ContactsPickerCoordinatorProtocol) {
|
|
}
|
|
|
|
func contactsPickerCoordinatorDidEndLoading(_ coordinator: ContactsPickerCoordinatorProtocol) {
|
|
}
|
|
|
|
func contactsPickerCoordinatorDidClose(_ coordinator: ContactsPickerCoordinatorProtocol) {
|
|
remove(childCoordinator: coordinator)
|
|
}
|
|
|
|
}
|
|
|
|
// MARK: - SpaceMembersCoordinatorDelegate
|
|
extension AllChatsViewController: SpaceMembersCoordinatorDelegate {
|
|
|
|
func spaceMembersCoordinatorDidCancel(_ coordinator: SpaceMembersCoordinatorType) {
|
|
coordinator.toPresentable().dismiss(animated: true) {
|
|
self.remove(childCoordinator: coordinator)
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// MARK: - BannerPresentationProtocol
|
|
extension AllChatsViewController: BannerPresentationProtocol {
|
|
func presentBannerView(_ bannerView: UIView, animated: Bool) {
|
|
self.bannerView = bannerView
|
|
}
|
|
|
|
func dismissBannerView(animated: Bool) {
|
|
self.bannerView = nil
|
|
}
|
|
}
|
|
|
|
// TODO: The `MasterTabBarViewController` is called from the entire app through the `LegacyAppDelegate`. this part of the code should be moved into `AppCoordinator`
|
|
// MARK: - SplitViewMasterViewControllerProtocol
|
|
extension AllChatsViewController: SplitViewMasterViewControllerProtocol {
|
|
|
|
/// Release the current selected item (if any).
|
|
func releaseSelectedItem() {
|
|
selectedRoomId = nil
|
|
selectedEventId = nil
|
|
selectedRoomSession = nil
|
|
selectedRoomPreviewData = nil
|
|
selectedContact = nil
|
|
}
|
|
|
|
/// Refresh the missed conversations badges on tab bar icon
|
|
func refreshTabBarBadges() {
|
|
// Nothing to do here as we don't have tab bar
|
|
}
|
|
|
|
/// Verify the current device if needed.
|
|
///
|
|
/// - Parameters:
|
|
/// - session: the matrix session.
|
|
func presentVerifyCurrentSessionAlertIfNeeded(with session: MXSession) {
|
|
guard !RiotSettings.shared.hideVerifyThisSessionAlert,
|
|
!isOnboardingInProgress,
|
|
presentedViewController == nil,
|
|
viewIfLoaded?.window != nil else {
|
|
return
|
|
}
|
|
|
|
// Force verification if required by the HS configuration
|
|
guard !session.vc_homeserverConfiguration().encryption.isSecureBackupRequired else {
|
|
MXLog.debug("[AllChatsViewController] presentVerifyCurrentSessionAlertIfNeededWithSession: Force verification of the device")
|
|
AppDelegate.theDelegate().presentCompleteSecurity(for: session)
|
|
return
|
|
}
|
|
|
|
presentVerifyCurrentSessionAlert(with: session)
|
|
}
|
|
|
|
/// Verify others device if needed.
|
|
///
|
|
/// - Parameters:
|
|
/// - session: the matrix session.
|
|
func presentReviewUnverifiedSessionsAlertIfNeeded(with session: MXSession) {
|
|
guard BuildSettings.showUnverifiedSessionsAlert,
|
|
!reviewSessionAlertSnoozeController.isSnoozed(),
|
|
presentedViewController == nil,
|
|
viewIfLoaded?.window != nil else {
|
|
return
|
|
}
|
|
|
|
if let userId = mainSession.myUserId, let crypto = mainSession.crypto {
|
|
let devices = crypto.devices(forUser: userId).values
|
|
let userHasOneUnverifiedDevice = devices.contains(where: {!$0.trustLevel.isCrossSigningVerified})
|
|
if userHasOneUnverifiedDevice {
|
|
presentReviewUnverifiedSessionsAlert(with: session)
|
|
}
|
|
}
|
|
}
|
|
|
|
func showOnboardingFlow() {
|
|
MXLog.debug("[AllChatsViewController] showOnboardingFlow")
|
|
self.showOnboardingFlowAndResetSessionFlags(true)
|
|
}
|
|
|
|
/// Display the onboarding flow configured to log back into a soft logout session.
|
|
///
|
|
/// - Parameters:
|
|
/// - credentials: the credentials of the soft logout session.
|
|
func showSoftLogoutOnboardingFlow(with credentials: MXCredentials?) {
|
|
// This method can be called after the user chooses to clear their data as the MXSession
|
|
// is opened to call logout from. So we only set the credentials when authentication isn't
|
|
// in progress to prevent a second soft logout screen being shown.
|
|
guard self.onboardingCoordinatorBridgePresenter == nil && !self.isOnboardingCoordinatorPreparing else {
|
|
return
|
|
}
|
|
|
|
MXLog.debug("[AllChatsViewController] showAuthenticationScreenAfterSoftLogout")
|
|
AuthenticationService.shared.softLogoutCredentials = credentials
|
|
self.showOnboardingFlowAndResetSessionFlags(false)
|
|
}
|
|
|
|
/// Open the room with the provided identifier in a specific matrix session.
|
|
///
|
|
/// - Parameters:
|
|
/// - parameters: the presentation parameters that contains room information plus display information.
|
|
/// - completion: the block to execute at the end of the operation.
|
|
func selectRoom(with parameters: RoomNavigationParameters, completion: @escaping () -> Void) {
|
|
releaseSelectedItem()
|
|
|
|
selectedRoomId = parameters.roomId
|
|
selectedEventId = parameters.eventId
|
|
selectedRoomSession = parameters.mxSession
|
|
|
|
allChatsDelegate?.allChatsViewController(self, didSelectRoomWithParameters: parameters, completion: completion)
|
|
|
|
refreshSelectedControllerSelectedCellIfNeeded()
|
|
}
|
|
|
|
/// Open the RoomViewController to display the preview of a room that is unknown for the user.
|
|
/// This room can come from an email invitation link or a simple link to a room.
|
|
/// - Parameters:
|
|
/// - parameters: the presentation parameters that contains room preview information plus display information.
|
|
/// - completion: the block to execute at the end of the operation.
|
|
func selectRoomPreview(with parameters: RoomPreviewNavigationParameters, completion: (() -> Void)?) {
|
|
releaseSelectedItem()
|
|
|
|
let roomPreviewData = parameters.previewData
|
|
|
|
selectedRoomPreviewData = roomPreviewData
|
|
selectedRoomId = roomPreviewData.roomId
|
|
selectedRoomSession = roomPreviewData.mxSession
|
|
|
|
allChatsDelegate?.allChatsViewController(self, didSelectRoomPreviewWithParameters: parameters, completion: completion)
|
|
|
|
refreshSelectedControllerSelectedCellIfNeeded()
|
|
}
|
|
|
|
/// Open a ContactDetailsViewController to display the information of the provided contact.
|
|
func select(_ contact: MXKContact) {
|
|
let presentationParameters = ScreenPresentationParameters(restoreInitialDisplay: true, stackAboveVisibleViews: false)
|
|
select(contact, with: presentationParameters)
|
|
}
|
|
|
|
/// Open a ContactDetailsViewController to display the information of the provided contact.
|
|
func select(_ contact: MXKContact, with presentationParameters: ScreenPresentationParameters) {
|
|
releaseSelectedItem()
|
|
|
|
selectedContact = contact
|
|
|
|
allChatsDelegate?.allChatsViewController(self, didSelectContact: contact, with: presentationParameters)
|
|
|
|
refreshSelectedControllerSelectedCellIfNeeded()
|
|
}
|
|
|
|
/// The current number of rooms with missed notifications, including the invites.
|
|
func missedDiscussionsCount() -> UInt {
|
|
guard let session = mxSessions as? [MXSession] else {
|
|
return 0
|
|
}
|
|
|
|
return session.reduce(0) { $0 + $1.vc_missedDiscussionsCount() }
|
|
}
|
|
|
|
/// The current number of rooms with unread highlighted messages.
|
|
func missedHighlightDiscussionsCount() -> UInt {
|
|
guard let session = mxSessions as? [MXSession] else {
|
|
return 0
|
|
}
|
|
|
|
return session.reduce(0) { $0 + $1.missedHighlightDiscussionsCount() }
|
|
}
|
|
|
|
/// Emulated `UItabBarViewController.selectedViewController` member
|
|
var selectedViewController: UIViewController? {
|
|
return self
|
|
}
|
|
|
|
var tabBar: UITabBar? {
|
|
return nil
|
|
}
|
|
|
|
func bwiOnUnlockedByPin() {
|
|
// bwi specific
|
|
|
|
}
|
|
|
|
// MARK: - Private
|
|
|
|
private func presentVerifyCurrentSessionAlert(with session: MXSession) {
|
|
MXLog.debug("[AllChatsViewController] presentVerifyCurrentSessionAlertWithSession")
|
|
|
|
let title: String
|
|
let message: String
|
|
|
|
if MXSDKOptions.sharedInstance().cryptoMigrationDelegate?.needsVerificationUpgrade == true {
|
|
title = VectorL10n.keyVerificationSelfVerifySecurityUpgradeAlertTitle
|
|
message = VectorL10n.keyVerificationSelfVerifySecurityUpgradeAlertMessage
|
|
} else {
|
|
title = VectorL10n.keyVerificationSelfVerifyCurrentSessionAlertTitle
|
|
message = VectorL10n.keyVerificationSelfVerifyCurrentSessionAlertMessage
|
|
}
|
|
|
|
let alert = UIAlertController(title: title,
|
|
message: message,
|
|
preferredStyle: .alert)
|
|
|
|
alert.addAction(UIAlertAction(title: VectorL10n.keyVerificationSelfVerifyCurrentSessionAlertValidateAction,
|
|
style: .default,
|
|
handler: { action in
|
|
AppDelegate.theDelegate().presentCompleteSecurity(for: session)
|
|
}))
|
|
|
|
alert.addAction(UIAlertAction(title: VectorL10n.later, style: .cancel))
|
|
|
|
alert.addAction(UIAlertAction(title: VectorL10n.doNotAskAgain,
|
|
style: .destructive,
|
|
handler: { action in
|
|
RiotSettings.shared.hideVerifyThisSessionAlert = true
|
|
}))
|
|
|
|
self.present(alert, animated: true)
|
|
}
|
|
|
|
private func presentReviewUnverifiedSessionsAlert(with session: MXSession) {
|
|
MXLog.debug("[AllChatsViewController] presentReviewUnverifiedSessionsAlert")
|
|
|
|
let alert = UIAlertController(title: VectorL10n.keyVerificationAlertTitle,
|
|
message: VectorL10n.keyVerificationAlertBody,
|
|
preferredStyle: .alert)
|
|
|
|
alert.addAction(UIAlertAction(title: VectorL10n.keyVerificationSelfVerifyUnverifiedSessionsAlertValidateAction,
|
|
style: .default,
|
|
handler: { action in
|
|
self.showSettingsSecurityScreen(with: session)
|
|
}))
|
|
|
|
alert.addAction(UIAlertAction(title: VectorL10n.later, style: .cancel, handler: { [weak self] _ in
|
|
self?.reviewSessionAlertSnoozeController.snooze()
|
|
}))
|
|
|
|
present(alert, animated: true)
|
|
}
|
|
|
|
private func showSettingsSecurityScreen(with session: MXSession) {
|
|
guard let settingsViewController = SettingsViewController.instantiate() else {
|
|
MXLog.warning("[AllChatsViewController] showSettingsSecurityScreen: cannot instantiate SettingsViewController")
|
|
return
|
|
}
|
|
|
|
guard let securityViewController = SecurityViewController.instantiate(withMatrixSession: session) else {
|
|
MXLog.warning("[AllChatsViewController] showSettingsSecurityScreen: cannot instantiate SecurityViewController")
|
|
return
|
|
}
|
|
|
|
settingsViewController.loadViewIfNeeded()
|
|
AppDelegate.theDelegate().restoreInitialDisplay {
|
|
if RiotSettings.shared.enableNewSessionManager || BWIBuildSettings.shared.enableNewSessionManagerByDefault {
|
|
self.navigationController?.viewControllers = [self, settingsViewController]
|
|
settingsViewController.showUserSessionsFlow()
|
|
} else {
|
|
self.navigationController?.viewControllers = [self, settingsViewController, securityViewController]
|
|
}
|
|
}
|
|
}
|
|
|
|
private func showOnboardingFlowAndResetSessionFlags(_ resetSessionFlags: Bool) {
|
|
// Check whether an authentication screen is not already shown or preparing
|
|
guard self.onboardingCoordinatorBridgePresenter == nil && !self.isOnboardingCoordinatorPreparing else {
|
|
return
|
|
}
|
|
|
|
self.isOnboardingCoordinatorPreparing = true
|
|
self.isOnboardingInProgress = true
|
|
|
|
if resetSessionFlags {
|
|
resetReviewSessionsFlags()
|
|
}
|
|
|
|
AppDelegate.theDelegate().restoreInitialDisplay {
|
|
self.presentOnboardingFlow()
|
|
}
|
|
}
|
|
|
|
private func resetReviewSessionsFlags() {
|
|
RiotSettings.shared.hideVerifyThisSessionAlert = false
|
|
}
|
|
|
|
private func presentOnboardingFlow() {
|
|
MXLog.debug("[AllChatsViewController] presentOnboardingFlow")
|
|
|
|
let onboardingCoordinatorBridgePresenter = OnboardingCoordinatorBridgePresenter()
|
|
onboardingCoordinatorBridgePresenter.completion = { [weak self] in
|
|
guard let self = self else { return }
|
|
|
|
self.onboardingCoordinatorBridgePresenter?.dismiss(animated: true, completion: {
|
|
self.onboardingCoordinatorBridgePresenter = nil
|
|
})
|
|
|
|
self.isOnboardingInProgress = false // Must be set before calling didCompleteAuthentication
|
|
self.allChatsDelegate?.allChatsViewControllerDidCompleteAuthentication(self)
|
|
}
|
|
|
|
onboardingCoordinatorBridgePresenter.present(from: self, animated: true)
|
|
self.onboardingCoordinatorBridgePresenter = onboardingCoordinatorBridgePresenter
|
|
self.isOnboardingCoordinatorPreparing = false
|
|
}
|
|
|
|
private func refreshSelectedControllerSelectedCellIfNeeded() {
|
|
guard splitViewController != nil else {
|
|
return
|
|
}
|
|
|
|
// Refresh selected cell without scrolling the selected cell (We suppose it's visible here)
|
|
self.refreshCurrentSelectedCell(false)
|
|
}
|
|
}
|
|
|
|
private extension MXSpaceService {
|
|
var hasSpaceInvite: Bool {
|
|
spaceSummaries.contains(where: { $0.isJoined == false })
|
|
}
|
|
|
|
var missedNotificationsCount: UInt {
|
|
let notificationState = notificationCounter.homeNotificationState
|
|
let groupNotifications = notificationState.groupMissedDiscussionsCount
|
|
let directNotifications = notificationState.directMissedDiscussionsCount
|
|
|
|
// `notificationState.allCount` returns twice the messages for favourite rooms. Fixing it here.
|
|
return groupNotifications + directNotifications
|
|
}
|
|
|
|
var hasHighlightNotification: Bool {
|
|
notificationCounter.homeNotificationState.allHighlightCount > 0
|
|
}
|
|
}
|