260 lines
12 KiB
Swift
260 lines
12 KiB
Swift
//
|
|
// AccessibilityHandler.swift
|
|
// MVMCoreUI
|
|
//
|
|
// Created by Bandaru, Krishna Kishore on 30/06/23.
|
|
// Copyright © 2023 Verizon Wireless. All rights reserved.
|
|
//
|
|
|
|
import Foundation
|
|
import Combine
|
|
import MVMCore
|
|
import WebKit
|
|
|
|
public class AccessbilityOperation: MVMCoreOperation {
|
|
|
|
private let argument: Any?
|
|
private let notificationType: UIAccessibility.Notification
|
|
private var timerSource: DispatchSourceTimer?
|
|
|
|
public init(notificationType: UIAccessibility.Notification, argument: Any?) {
|
|
self.notificationType = notificationType
|
|
self.argument = argument
|
|
}
|
|
|
|
public override func main() {
|
|
guard UIAccessibility.isVoiceOverRunning, !checkAndHandleForCancellation() else {
|
|
stop()
|
|
return
|
|
}
|
|
timerSource = DispatchSource.makeTimerSource()
|
|
timerSource?.setEventHandler {
|
|
Task { @MainActor [weak self] in
|
|
guard let self = self, !self.isCancelled else {
|
|
self?.stop()
|
|
return
|
|
}
|
|
UIAccessibility.post(notification: self.notificationType, argument: self.argument)
|
|
self.markAsFinished()
|
|
}
|
|
}
|
|
timerSource?.schedule(deadline: .now())
|
|
timerSource?.activate()
|
|
}
|
|
|
|
public func stop() {
|
|
guard isCancelled else { return }
|
|
timerSource?.cancel()
|
|
markAsFinished()
|
|
}
|
|
}
|
|
|
|
open class AccessibilityHandler {
|
|
|
|
public static func shared() -> Self? {
|
|
guard let shared = CoreUIObject.sharedInstance()?.accessibilityHandler else { return nil }
|
|
return MVMCoreActionUtility.fatalClassCheck(object: shared)
|
|
}
|
|
|
|
public var previousAccessiblityElement: Any?
|
|
public var anyCancellable: Set<AnyCancellable> = []
|
|
public weak var delegate: MVMCoreViewControllerProtocol?
|
|
|
|
private var accessibilityOperationQueue: OperationQueue = {
|
|
let queue = OperationQueue()
|
|
queue.maxConcurrentOperationCount = 1
|
|
return queue
|
|
}()
|
|
private(set) var accessibilityId: String?
|
|
private var announcementText: String?
|
|
private(set) var hasTopNotitificationInPage: Bool = false
|
|
|
|
public init() {
|
|
registerWithResponseLoaded()
|
|
registerForPageChanges()
|
|
registerForFocusChanges()
|
|
}
|
|
|
|
// MARK: - Register with Accessibility Handler listeners
|
|
/// Registers with the notification center to know when json is updated and to capture previous accessbility focused id & announcment text
|
|
private func registerWithResponseLoaded() {
|
|
NotificationCenter.default.publisher(for: NSNotification.Name(rawValue: NotificationResponseLoaded))
|
|
.sink { [weak self] notification in
|
|
self?.accessibilityId = (notification.userInfo?[String(describing: MVMCoreLoadObject.self)] as? MVMCoreLoadObject)?.pageJSON?.optionalStringForKey("accessibilityId")
|
|
self?.announcementText = (notification.userInfo?[String(describing: MVMCoreLoadObject.self)] as? MVMCoreLoadObject)?.pageJSON?.optionalStringForKey("announcementText")
|
|
}.store(in: &anyCancellable)
|
|
}
|
|
|
|
private func registerForFocusChanges() {
|
|
//Since foucs shifted to other elements cancelling existing focus shift notifications if any
|
|
NotificationCenter.default.publisher(for: UIAccessibility.elementFocusedNotification)
|
|
.sink { [weak self] _ in
|
|
self?.cancelAllOperations()
|
|
}.store(in: &anyCancellable)
|
|
}
|
|
|
|
func registerForTopNotificationsChanges() {
|
|
NotificationHandler.shared()?.onNotificationWillShow
|
|
.sink { [weak self] (_, model) in
|
|
self?.hasTopNotitificationInPage = true
|
|
self?.capturePreviousFocusElement()
|
|
}.store(in: &anyCancellable)
|
|
NotificationHandler.shared()?.onNotificationShown
|
|
.sink { [weak self] (view, model) in
|
|
self?.post(notification: .layoutChanged, argument: view)
|
|
}.store(in: &anyCancellable)
|
|
NotificationHandler.shared()?.onNotificationWillDismiss
|
|
.sink { [weak self] (view, model) in
|
|
self?.post(notification: .announcement, argument: MVMCoreUIUtility.hardcodedString(withKey: "AccTopAlertClosed"))
|
|
}.store(in: &anyCancellable)
|
|
NotificationHandler.shared()?.onNotificationDismissed
|
|
.sink { [weak self] (view, model) in
|
|
self?.postAccessbilityToPrevElement()
|
|
}.store(in: &anyCancellable)
|
|
}
|
|
|
|
/// Registers to know when pages change.
|
|
open func registerForPageChanges() {
|
|
NavigationHandler.shared()
|
|
.onNavigation
|
|
.sink { [self] (event, operation) in
|
|
switch event {
|
|
case .willNavigate:
|
|
willNavigate(operation)
|
|
default:
|
|
break
|
|
}
|
|
}.store(in: &anyCancellable)
|
|
}
|
|
|
|
private func willNavigate(_ operation: NavigationOperation) {
|
|
previousAccessiblityElement = nil
|
|
if let announcementText {
|
|
post(notification: .announcement, argument: announcementText)
|
|
}
|
|
if let subNavManagerController = operation.toNavigationControllerViewControllers?.last as? SubNavManagerController {
|
|
delegate = subNavManagerController.getCurrentViewController() as? MVMCoreViewControllerProtocol
|
|
} else {
|
|
delegate = operation.toNavigationControllerViewControllers?.last as? MVMCoreViewControllerProtocol
|
|
}
|
|
}
|
|
|
|
// MARK: - Accessibility Handler operation events
|
|
open func capturePreviousFocusElement() {
|
|
previousAccessiblityElement = UIAccessibility.focusedElement(using: .notificationVoiceOver)
|
|
}
|
|
|
|
open func postAccessbilityToPrevElement() {
|
|
post(notification: .layoutChanged, argument: previousAccessiblityElement)
|
|
}
|
|
|
|
private func add(operation: Operation) {
|
|
accessibilityOperationQueue.addOperation(operation)
|
|
}
|
|
|
|
private func cancelAllOperations() {
|
|
accessibilityOperationQueue.cancelAllOperations()
|
|
}
|
|
|
|
public func post(notification type: UIAccessibility.Notification, argument: Any? = nil) {
|
|
guard UIAccessibility.isVoiceOverRunning else { return }
|
|
let accessbilityOperation = AccessbilityOperation(notificationType: type, argument: argument)
|
|
add(operation: accessbilityOperation)
|
|
}
|
|
|
|
//To get first focus element on the screen
|
|
open func getFirstFocusedElementOnScreen() -> Any? {
|
|
(delegate as? UIViewController)?.navigationItem.leftBarButtonItem ?? (delegate as? UIViewController)?.navigationItem.titleView ?? (delegate as? UIViewController)?.navigationController?.navigationBar
|
|
}
|
|
|
|
//Subclass can decide to trigger Accessibility notification on screen change.
|
|
open func canPostAccessbilityNotification(for viewController: UIViewController) -> Bool { true }
|
|
|
|
func getPreDefinedFocusedElementIfAny() -> UIView? {
|
|
guard let accessibilityId, let models: [any Identifiable] = (delegate?.delegateObject?() as? MVMCoreUIDelegateObject)?.moleculeDelegate?.getRootMolecules().allMoleculesOfType() else { return nil }
|
|
guard !models.isEmpty,
|
|
let model = (models.filter { ($0.id as? String) == accessibilityId }).first else { return nil }
|
|
return (delegate as? UIViewController)?.view?.getMoleculeViews { (subView: MoleculeViewProtocol) in
|
|
guard let moleculeModel = (subView as? MoleculeViewModelProtocol)?.moleculeModel as? (any Identifiable),
|
|
(moleculeModel.id as? String) == (model.id as? String) else {
|
|
return false
|
|
}
|
|
return true
|
|
}.first
|
|
}
|
|
}
|
|
|
|
// MARK: - Accessibility Handler Behaviour
|
|
///Accessibility Handler Behaviour to detect page shown and post notification to first interactive element on screen or the pre-defined focused element.
|
|
struct AccessibilityHandlerBehaviorModel: PageBehaviorModelProtocol {
|
|
|
|
var shouldAllowMultipleInstances = false
|
|
static var identifier = "accessibilityHandlerBehaviorModel"
|
|
}
|
|
|
|
class AccessibilityHandlerBehavior: PageVisibilityBehavior {
|
|
|
|
private var delegateObj: MVMCoreUIDelegateObject?
|
|
private var anyCancellable: Set<AnyCancellable> = []
|
|
|
|
required public init(model: PageBehaviorModelProtocol, delegateObject: MVMCoreUIDelegateObject?) { }
|
|
|
|
public func willShowPage(_ delegateObject: MVMCoreUIDelegateObject?) {
|
|
guard let controller = delegateObject?.moleculeDelegate as? UIViewController,
|
|
(AccessibilityHandler.shared()?.canPostAccessbilityNotification(for: controller) ?? true),
|
|
AccessibilityHandler.shared()?.accessibilityId == nil else { return }
|
|
if AccessibilityHandler.shared()?.hasTopNotitificationInPage ?? false {
|
|
AccessibilityHandler.shared()?.previousAccessiblityElement = AccessibilityHandler.shared()?.getFirstFocusedElementOnScreen()
|
|
} else {
|
|
AccessibilityHandler.shared()?.post(notification: .layoutChanged, argument: AccessibilityHandler.shared()?.getFirstFocusedElementOnScreen())
|
|
}
|
|
delegateObj = delegateObject
|
|
}
|
|
|
|
///We need to shift focus to any element mentioned in server response i.e to retain focus of the element in new page, from where action is triggered.
|
|
///https://oneconfluence.verizon.com/display/MFD/Accessibility+-+Focus+Retain
|
|
func onPageShown(_ delegateObject: MVMCoreUIDelegateObject?) {
|
|
updateAccessibilityViews(delegateObject) //To track FAB & HAB elements on UI
|
|
guard let accessibilityElement = AccessibilityHandler.shared()?.getPreDefinedFocusedElementIfAny() else { return }
|
|
if AccessibilityHandler.shared()?.hasTopNotitificationInPage ?? false {
|
|
AccessibilityHandler.shared()?.previousAccessiblityElement = accessibilityElement
|
|
} else {
|
|
AccessibilityHandler.shared()?.post(notification: .layoutChanged, argument: accessibilityElement)
|
|
}
|
|
}
|
|
|
|
private func updateAccessibilityViews(_ delegateObject: MVMCoreUIDelegateObject?) {
|
|
var accessibilityElements: [Any?] = [MVMCoreUISplitViewController.main()?.topAlertView]
|
|
if let managerController = (delegateObject?.moleculeDelegate as? MVMCoreViewManagerViewControllerProtocol)?.manager as? SubNavManagerController {
|
|
accessibilityElements.append(managerController.navigationController)
|
|
accessibilityElements.append(managerController.tabs)
|
|
accessibilityElements.append(contentsOf: managerController.view.subviews)
|
|
accessibilityElements.append(MVMCoreUISplitViewController.main()?.tabBar)
|
|
managerController.view.accessibilityElements = accessibilityElements.compactMap { $0 }
|
|
} else if let controller = delegateObject?.moleculeDelegate as? UIViewController {
|
|
accessibilityElements.append(controller.navigationController)
|
|
accessibilityElements.append(contentsOf: controller.view.subviews.reversed())
|
|
accessibilityElements.append(MVMCoreUISplitViewController.main()?.tabBar)
|
|
controller.view.accessibilityElements = accessibilityElements.compactMap { $0 }
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - Helpers
|
|
extension UIView {
|
|
|
|
private func getNestedSubviews<T>() -> [T] {
|
|
subviews.flatMap { subView -> [T] in
|
|
var result = subView.getNestedSubviews() as [T]
|
|
if let view = subView as? T { result.append(view) }
|
|
return result
|
|
}
|
|
}
|
|
|
|
func getMoleculeViews<T>(filter: ((T) -> Bool)) -> [T] {
|
|
return getNestedSubviews().compactMap {
|
|
filter($0) ? $0 : nil
|
|
}
|
|
}
|
|
}
|