Cleaned up some more code

Author: Bianca Marina Stana

Assets/Scripts/Gameplay/GameViewController.cs

@@ -308,30 +308,20 @@ void MoveCard(bool shouldMoveLeft, int count)
                 // Announce that the card was moved.
                 AssistiveSupport.notificationDispatcher.SendAnnouncement(announcement);
 
-                // On iOS, the accessibility hierarchy is flattened. This means that nodes don't have parents or
-                // children, so functions that require them (like AccessibilityHierarchy.MoveNode) won't work. Hence,
-                // we need to recreate the whole hierarchy instead.
-                if (Application.platform == RuntimePlatform.IPhonePlayer)
-                {
-                    AccessibilityManager.GetService<UGuiAccessibilityService>()?.RebuildHierarchy();
-                    m_WasHierarchyRefreshed = true;
+                AssistiveSupport.activeHierarchy.MoveNode(element.node, element.node.parent,
+                    element.transform.GetSiblingIndex());
 
-                    // Add the node count to the element ID to match the ID of the node in the refreshed hierarchy,
-                    // ensuring consistent focus even after rebuilding.
-                    var nodeToFocusId = element.node.id + AccessibilityManager.hierarchy.rootNodes.Count;
-                    nodeToFocusId += shouldMoveLeft ? -count : count;
+                // Only refresh the frames for now to leave the announcement request to be handled.
+                StartCoroutine(RefreshNodeFrames());
 
-                    StartCoroutine(this.FocusOnNode(nodeToFocusId));
-                }
-                else
-                {
-                    AccessibilityManager.hierarchy.MoveNode(element.node, element.node.parent,
-                        element.transform.GetSiblingIndex());
+                AssistiveSupport.notificationDispatcher.SendLayoutChanged(element.node);
+                return;
 
-                    // Only refresh the frames for now to leave the announcement request to be handled.
-                    StartCoroutine(this.RefreshNodeFrames());
+                IEnumerator RefreshNodeFrames()
+                {
+                    yield return new WaitForEndOfFrame();
 
-                    AssistiveSupport.notificationDispatcher.SendLayoutChanged(element.node);
+                    AssistiveSupport.activeHierarchy?.RefreshNodeFrames();
                 }
             }
         }

Assets/Scripts/Screen Reader/AccessibilityService.cs

@@ -8,7 +8,7 @@ namespace Unity.Samples.ScreenReader
     public abstract class AccessibilityService
     {
         /// <summary>
-        /// The accessibility sub hierarchy that this service operates on.
+        /// The accessibility sub-hierarchy that this service operates on.
         /// </summary>
         public AccessibilitySubHierarchy hierarchy { get; set; }
 

Assets/Scripts/Screen Reader/AccessibilitySubHierarchy.cs

@@ -4,28 +4,28 @@
 namespace Unity.Samples.ScreenReader
 {
     /// <summary>
-    /// This represents a sub hierarchy of an AccessibilityHierarchy created from a specific node that is used
-    /// as root for the sub hierarchy.
+    /// This represents a sub-hierarchy of an AccessibilityHierarchy created from a specific node that is used
+    /// as root for the sub-hierarchy.
     /// </summary>
     public struct AccessibilitySubHierarchy
     {
         /// <summary>
-        /// The main accessibility hierarchy that this sub hierarchy belongs to.
+        /// The main accessibility hierarchy that this sub-hierarchy belongs to.
         /// </summary>
         public AccessibilityHierarchy mainHierarchy { get; private set; }
 
         /// <summary>
-        /// Returns the node used as root for this sub hierarchy.
+        /// Returns the node used as root for this sub-hierarchy.
         /// </summary>
         public AccessibilityNode rootNode { get; private set; }
 
         /// <summary>
-        /// Returns true if this sub hierarchy is valid.
+        /// Returns true if this sub-hierarchy is valid.
         /// </summary>
         public bool isValid => mainHierarchy != null;
 
         /// <summary>
-        /// Constructs a sub hierarchy from the specified hierarchy and root node.
+        /// Constructs a sub-hierarchy from the specified hierarchy and root node.
         /// </summary>
         /// <param name="mainHierarchy"></param>
         /// <param name="rootNode"></param>
@@ -43,13 +43,13 @@ public AccessibilitySubHierarchy(AccessibilityHierarchy mainHierarchy, Accessibi
                 throw new System.ArgumentException("The root node must belong to the main hierarchy.", nameof(rootNode));
             }
 
-            // Note: if the root element is null then the sub hierarchy represents the whole hierarchy.
+            // Note: if the root element is null then the sub-hierarchy represents the whole hierarchy.
             this.mainHierarchy = mainHierarchy;
             this.rootNode = rootNode;
         }
 
         /// <summary>
-        /// Disposes the sub hierarchy removing the root node from the main hierarchy.
+        /// Disposes the sub-hierarchy removing the root node from the main hierarchy.
         /// </summary>
         public void Dispose()
         {
@@ -63,7 +63,7 @@ public void Dispose()
         }
 
         /// <summary>
-        /// Returns true if the specified node belongs to this sub hierarchy.
+        /// Returns true if the specified node belongs to this sub-hierarchy.
         /// </summary>
         /// <param name="node"></param>
         /// <returns></returns>
@@ -79,7 +79,7 @@ public bool ContainsNode(AccessibilityNode node)
                 return false;
             }
 
-            // We know the node is in the main hierarchy, now we need to check if it's part of this sub hierarchy.
+            // We know the node is in the main hierarchy, now we need to check if it's part of this sub-hierarchy.
             var parentNode = node.parent;
 
             while (parentNode != null)
@@ -96,7 +96,7 @@ public bool ContainsNode(AccessibilityNode node)
         }
 
         /// <summary>
-        /// Tries to get the node with the specified id if it belongs to this sub hierarchy.
+        /// Tries to get the node with the specified id if it belongs to this sub-hierarchy.
         /// </summary>
         /// <param name="id">The id of the node to seek</param>
         /// <param name="node">The node found</param>
@@ -114,7 +114,7 @@ public bool TryGetNode(int id, out AccessibilityNode node)
         }
 
         /// <summary>
-        /// Tries to get the node at the specified position if it belongs to this sub hierarchy.
+        /// Tries to get the node at the specified position if it belongs to this sub-hierarchy.
         /// </summary>
         /// <param name="horizontalPosition">The x position</param>
         /// <param name="verticalPosition">The y position</param>
@@ -155,7 +155,7 @@ public AccessibilityNode InsertNode(int childIndex, string label = null, Accessi
         {
             if (parent != null && !ContainsNode(parent))
             {
-                Debug.LogError("The specified parent node does not belong to this sub hierarchy.");
+                Debug.LogError("The specified parent node does not belong to this sub-hierarchy.");
                 return null;
             }
 
@@ -184,7 +184,7 @@ public bool MoveNode(AccessibilityNode node, AccessibilityNode newParent, int ne
         }
 
         /// <summary>
-        /// Removes the specified node from this sub hierarchy.
+        /// Removes the specified node from this sub-hierarchy.
         /// </summary>
         /// <param name="node">The node to remove</param>
         /// <param name="removeChildren"></param>
@@ -199,7 +199,7 @@ public void RemoveNode(AccessibilityNode node, bool removeChildren = true)
         }
 
         /// <summary>
-        /// Removes all nodes from this sub hierarchy.
+        /// Removes all nodes from this sub-hierarchy.
         /// </summary>
         public void Clear()
         {
@@ -213,22 +213,22 @@ public void Clear()
             }
             else
             {
-                // If the sub hierarchy has no root node, we clear the whole hierarchy.
+                // If the sub-hierarchy has no root node, we clear the whole hierarchy.
                 mainHierarchy.Clear();
             }
         }
 
         /// <summary>
-        /// Refreshes the frames of all nodes in this sub hierarchy.
+        /// Refreshes the frames of all nodes in this sub-hierarchy.
         /// </summary>
         public void RefreshNodeFrames()
         {
-            // TODO: Optimize to only refresh nodes in this sub hierarchy.
+            // TODO: Optimize to only refresh nodes in this sub-hierarchy.
             mainHierarchy.RefreshNodeFrames();
         }
 
         /// <summary>
-        /// Returns the lowest common ancestor of the two specified nodes if they both belong to this sub hierarchy.
+        /// Returns the lowest common ancestor of the two specified nodes if they both belong to this sub-hierarchy.
         /// </summary>
         /// <param name="firstNode">The first node</param>
         /// <param name="secondNode">The second node</param>

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

@@ -37,7 +37,7 @@ enum NotificationType
         AccessibilitySubHierarchy m_SubHierarchy;
 
         /// <summary>
-        /// The sub hierarchy this updater is managing.
+        /// The sub-hierarchy this updater is managing.
         /// </summary>
         public AccessibilitySubHierarchy hierarchy
         {
@@ -569,7 +569,7 @@ void Update(VisualElement visualTree)
                     var rootNode = m_AccessibilityService.hierarchy.AddNode(string.IsNullOrEmpty(panelName) ?
                         visualTree.name : panelName);
                     rootNode.role = AccessibilityRole.Container;
-                    rootNode.isActive = (Application.platform == RuntimePlatform.OSXPlayer);
+                    rootNode.isActive = Application.platform == RuntimePlatform.OSXPlayer;
                     hierarchy = new AccessibilitySubHierarchy(m_AccessibilityService.hierarchy.mainHierarchy, rootNode);
                     DirtyRootFrame();
                     shouldSendNotification = true;
@@ -681,7 +681,7 @@ void UpdateAccessibilityHierarchyRecursively(VisualElement element,
                 }
             }
 
-            // Update the model element.
+            // Update the modal element.
             if (!shouldBeIgnored && modal)
             {
                 currentModalElement = element;
@@ -691,8 +691,8 @@ void UpdateAccessibilityHierarchyRecursively(VisualElement element,
                 currentModalElement = null;
             }
 
-            // Note that we still travers the children even if the parent is ignored.
-            // It is possible that nodes for children were created and has to be destroyed and the handlers cleaned up.
+            // Note that we still traverse the children even if the parent is ignored.
+            // It is possible that nodes for children were created and have to be destroyed and the handlers cleaned up.
             foreach (var child in element.hierarchy.Children())
             {
                 UpdateAccessibilityHierarchyRecursively(child, parentAccessible, forced, visible && !shouldBeIgnored);