Added missing functionality to accessibility handlers and cleaned up some more code

Author: Bianca Marina Stana

Assets/Scripts/Gameplay/GameViewController.cs

@@ -304,6 +304,7 @@ void MoveCard(bool shouldMoveLeft, int count)
                 var otherSibling = draggable.transform.parent.GetChild(otherSiblingIndex);
 
                 // Make the letter uppercase to ensure correct phonetic pronunciation.
+                // TODO: This should be localized.
                 var announcement = $"Moved {draggable.name.ToUpper()} {(shouldMoveLeft ? "before" : "after")} {otherSibling.name.ToUpper()}";
 
                 // Announce that the card was moved.

Assets/Scripts/Screen Reader/UGUI/AccessibleElement.cs

@@ -34,23 +34,10 @@ public AccessibilityNode node
                     return;
                 }
 
-                DisconnectFromFocusChanged();
-                DisconnectFromSelected();
-                DisconnectFromIncremented();
-                DisconnectFromDecremented();
-                DisconnectFromScrolled();
-                DisconnectFromDismissed();
-
+                DisconnectFromNode();
                 m_Node = value;
-
                 SetNodeProperties();
-
-                ConnectToFocusChanged();
-                ConnectToSelected();
-                ConnectToIncremented();
-                ConnectToDecremented();
-                ConnectToScrolled();
-                ConnectToDismissed();
+                ConnectToNode();
             }
         }
 
@@ -175,6 +162,26 @@ protected virtual void UnbindFromControl()
 #endif // UNITY_6000_3_OR_NEWER
         }
 
+        void ConnectToNode()
+        {
+            ConnectToFocusChanged();
+            ConnectToSelected();
+            ConnectToIncremented();
+            ConnectToDecremented();
+            ConnectToScrolled();
+            ConnectToDismissed();
+        }
+
+        void DisconnectFromNode()
+        {
+            DisconnectFromFocusChanged();
+            DisconnectFromSelected();
+            DisconnectFromIncremented();
+            DisconnectFromDecremented();
+            DisconnectFromScrolled();
+            DisconnectFromDismissed();
+        }
+
         void ConnectToFocusChanged()
         {
             if (node == null)
@@ -186,6 +193,21 @@ void ConnectToFocusChanged()
             node.focusChanged += InvokeFocused;
         }
 
+        void DisconnectFromFocusChanged()
+        {
+            if (node == null)
+            {
+                return;
+            }
+
+            node.focusChanged -= InvokeFocused;
+        }
+
+        void InvokeFocused(AccessibilityNode accessibilityNode, bool isFocused)
+        {
+            focused?.Invoke(isFocused);
+        }
+
         void ConnectToSelected()
         {
             // Implementing the selected event tells the screen reader that the node is selectable, which may lead to
@@ -204,99 +226,93 @@ void ConnectToSelected()
 #endif // UNITY_6000_3_OR_NEWER
         }
 
-        void ConnectToIncremented()
+        void DisconnectFromSelected()
         {
             if (node == null)
             {
                 return;
             }
 
-            node.incremented -= InvokeIncremented;
-            node.incremented += InvokeIncremented;
+#if UNITY_6000_3_OR_NEWER
+            node.invoked -= InvokeSelected;
+#else // UNITY_6000_3_OR_NEWER
+            node.selected -= InvokeSelected;
+#endif // UNITY_6000_3_OR_NEWER
         }
 
-        void ConnectToDecremented()
+        bool InvokeSelected()
         {
-            if (node == null)
-            {
-                return;
-            }
+            var success = m_Selected?.Invoke() ?? false;
 
-            node.decremented -= InvokeDecremented;
-            node.decremented += InvokeDecremented;
+            node.value = value;
+            node.state = state;
+
+            return success;
         }
 
-        void ConnectToScrolled()
+        void ConnectToIncremented()
         {
-#if UNITY_6000_3_OR_NEWER
-            if (node == null || m_Scrolled == null)
+            if (node == null)
             {
                 return;
             }
 
-            node.scrolled -= InvokeScrolled;
-            node.scrolled += InvokeScrolled;
-#endif // UNITY_6000_3_OR_NEWER
+            node.incremented -= InvokeIncremented;
+            node.incremented += InvokeIncremented;
         }
 
-        void ConnectToDismissed()
+        void DisconnectFromIncremented()
         {
-            // Implementing the dismissed event tells the screen reader that the node is dismissible, which may lead to
-            // a specific behaviour. Therefore, we don't implement the node's dismissed event unless we actually need
-            // it.
-            if (node == null || m_Dismissed == null)
+            if (node == null)
             {
                 return;
             }
 
-#if UNITY_2023_3_OR_NEWER
-            node.dismissed -= InvokeDismissed;
-            node.dismissed += InvokeDismissed;
-#endif // UNITY_2023_3_OR_NEWER
+            node.incremented -= InvokeIncremented;
         }
 
-        void DisconnectFromFocusChanged()
+        void InvokeIncremented()
         {
-            if (node == null)
-            {
-                return;
-            }
-
-            node.focusChanged -= InvokeFocused;
+            incremented?.Invoke();
         }
 
-        void DisconnectFromSelected()
+        void ConnectToDecremented()
         {
             if (node == null)
             {
                 return;
             }
 
-#if UNITY_6000_3_OR_NEWER
-            node.invoked -= InvokeSelected;
-#else // UNITY_6000_3_OR_NEWER
-            node.selected -= InvokeSelected;
-#endif // UNITY_6000_3_OR_NEWER
+            node.decremented -= InvokeDecremented;
+            node.decremented += InvokeDecremented;
         }
 
-        void DisconnectFromIncremented()
+        void DisconnectFromDecremented()
         {
             if (node == null)
             {
                 return;
             }
 
-            node.incremented -= InvokeIncremented;
+            node.decremented -= InvokeDecremented;
         }
 
-        void DisconnectFromDecremented()
+        void InvokeDecremented()
         {
-            if (node == null)
+            decremented?.Invoke();
+        }
+
+        void ConnectToScrolled()
+        {
+#if UNITY_6000_3_OR_NEWER
+            if (node == null || m_Scrolled == null)
             {
                 return;
             }
 
-            node.decremented -= InvokeDecremented;
+            node.scrolled -= InvokeScrolled;
+            node.scrolled += InvokeScrolled;
+#endif // UNITY_6000_3_OR_NEWER
         }
 
         void DisconnectFromScrolled()
@@ -311,53 +327,44 @@ void DisconnectFromScrolled()
 #endif // UNITY_6000_3_OR_NEWER
         }
 
-        void DisconnectFromDismissed()
+#if UNITY_6000_3_OR_NEWER
+        bool InvokeScrolled(AccessibilityScrollDirection direction)
         {
-            if (node == null)
+            return m_Scrolled?.Invoke(direction) ?? false;
+        }
+#endif // UNITY_6000_3_OR_NEWER
+
+        void ConnectToDismissed()
+        {
+            // Implementing the dismissed event tells the screen reader that the node is dismissible, which may lead to
+            // a specific behaviour. Therefore, we don't implement the node's dismissed event unless we actually need
+            // it.
+            if (node == null || m_Dismissed == null)
             {
                 return;
             }
 
 #if UNITY_2023_3_OR_NEWER
             node.dismissed -= InvokeDismissed;
+            node.dismissed += InvokeDismissed;
 #endif // UNITY_2023_3_OR_NEWER
         }
 
-        void InvokeFocused(AccessibilityNode accessibilityNode, bool isFocused)
-        {
-            focused?.Invoke(isFocused);
-        }
-
-        bool InvokeSelected()
-        {
-            var success = m_Selected != null && m_Selected.Invoke();
-
-            node.value = value;
-            node.state = state;
-
-            return success;
-        }
-
-        internal void InvokeIncremented()
-        {
-            incremented?.Invoke();
-        }
-
-        internal void InvokeDecremented()
+        void DisconnectFromDismissed()
         {
-            decremented?.Invoke();
-        }
+            if (node == null)
+            {
+                return;
+            }
 
-#if UNITY_6000_3_OR_NEWER
-        bool InvokeScrolled(AccessibilityScrollDirection direction)
-        {
-            return m_Scrolled != null && m_Scrolled.Invoke(direction);
+#if UNITY_2023_3_OR_NEWER
+            node.dismissed -= InvokeDismissed;
+#endif // UNITY_2023_3_OR_NEWER
         }
-#endif // UNITY_6000_3_OR_NEWER
 
         bool InvokeDismissed()
         {
-            return m_Dismissed != null && m_Dismissed.Invoke();
+            return m_Dismissed?.Invoke() ?? false;
         }
 
         public void SetNodeProperties()

Assets/Scripts/Screen Reader/UGUI/AccessibleInput.cs

@@ -2,6 +2,7 @@
 using UnityEngine;
 using UnityEngine.Accessibility;
 using UnityEngine.EventSystems;
+using UnityEngine.Localization.Settings;
 using UnityEngine.UI;
 
 namespace Unity.Samples.ScreenReader
@@ -51,7 +52,12 @@ void Start()
                 UpdateValue(m_InputField.text);
             }
 
-            hint = "Double tap to edit.";
+            // if (Application.platform == RuntimePlatform.Android ||
+            //     Application.platform == RuntimePlatform.IPhonePlayer)
+            // {
+            //     // TODO: "Double tap to edit." should be localized.
+            //     hint = LocalizationSettings.StringDatabase.GetLocalizedString("", "");
+            // }
         }
 
         protected override void BindToControl()

Assets/Scripts/Screen Reader/UITk/AccessibleProperties.cs

@@ -117,9 +117,17 @@ public bool allowsDirectInteraction
             set => m_AllowsDirectInteraction.Set(this, value);
         }
 
+        public event Action<bool> focused;
         public event Func<bool> selected;
-        public Action incremented;
-        public Action decremented;
+        public event Action incremented;
+        public event Action decremented;
+        public event Func<AccessibilityScrollDirection, bool> scrolled;
+        public event Func<bool> dismissed;
+
+        internal void InvokeFocused(AccessibilityNode accessibilityNode, bool isFocused)
+        {
+            focused?.Invoke(isFocused);
+        }
 
         internal bool InvokeSelected()
         {
@@ -135,23 +143,33 @@ internal void InvokeDecremented()
         {
             decremented?.Invoke();
         }
+
+        internal bool InvokeScrolled(AccessibilityScrollDirection direction)
+        {
+            return scrolled?.Invoke(direction) ?? false;
+        }
+
+        internal bool InvokeDismissed()
+        {
+            return dismissed?.Invoke() ?? false;
+        }
     }
 
     public static class AccessibilityVisualElementExtensions
     {
-        static Dictionary<VisualElement, AccessibleProperties> m_AttachedAccessibleProperties = new();
+        static Dictionary<VisualElement, AccessibleProperties> s_AttachedAccessibleProperties = new();
 
         static AccessibleProperties GetAttachedAccessibleProperties(VisualElement ve)
         {
-            return m_AttachedAccessibleProperties.GetValueOrDefault(ve);
+            return s_AttachedAccessibleProperties.GetValueOrDefault(ve);
         }
 
         static AccessibleProperties AttachAccessibleProperties(VisualElement ve)
         {
             var accessible = new AccessibleProperties();
             accessible.owner = ve;
 
-            m_AttachedAccessibleProperties[ve] = accessible;
+            s_AttachedAccessibleProperties[ve] = accessible;
 
             return accessible;
         }

Assets/Scripts/Screen Reader/UITk/Handlers/ButtonHandler.cs

@@ -7,6 +7,23 @@ namespace Unity.Samples.ScreenReader
     [Preserve]
     class ButtonHandler : VisualElementAccessibilityHandler
     {
+        public ButtonHandler()
+        {
+            selected += () =>
+            {
+                if (ownerElement is not Button button)
+                {
+                    return false;
+                }
+
+                using var e = new NavigationSubmitEvent();
+                e.target = button;
+                button.SendEvent(e);
+
+                return true;
+            };
+        }
+
         public override string GetLabel()
         {
             return (ownerElement as Button)?.text;