feat(focus-mvp-android-device): wire up components for focus visualization (#86)

* feat(focus-mvp-android-device): wire up components for focus visualization

* wire up such that everything is functional without tests

* updated with tests

* style fixes

* removed unnecessary redraw event type

Author: waabid

AccessibilityInsightsForAndroidService/app/src/main/AndroidManifest.xml

@@ -20,6 +20,7 @@
     package="com.microsoft.accessibilityinsightsforandroidservice">
 
     <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />
     <application
         android:allowBackup="false"
         android:icon="@mipmap/blue_launcher"

AccessibilityInsightsForAndroidService/app/src/main/java/com/microsoft/accessibilityinsightsforandroidservice/AccessibilityEventDispatcher.java

@@ -26,15 +26,16 @@ public AccessibilityEventDispatcher() {
 
   public static List<Integer> redrawEventTypes =
       Arrays.asList(
-          AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED,
           AccessibilityEvent.TYPE_VIEW_SCROLLED,
           AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED,
           AccessibilityEvent.TYPE_WINDOWS_CHANGED);
 
   public void onAccessibilityEvent(AccessibilityEvent event, AccessibilityNodeInfo rootNode) {
     int eventType = event.getEventType();
 
-    if (previousPackageName == null || !previousPackageName.equals(rootNode.getPackageName())) {
+    if (rootNode != null
+        && (previousPackageName == null
+            || !previousPackageName.equals(rootNode.getPackageName()))) {
       previousPackageName = rootNode.getPackageName();
       this.callListeners(onAppChangedListeners, rootNode);
     }

AccessibilityInsightsForAndroidService/app/src/main/java/com/microsoft/accessibilityinsightsforandroidservice/AccessibilityInsightsForAndroidService.java

@@ -24,6 +24,7 @@
 import android.os.Handler;
 import android.os.HandlerThread;
 import android.util.DisplayMetrics;
+import android.view.WindowManager;
 import android.view.accessibility.AccessibilityEvent;
 
 public class AccessibilityInsightsForAndroidService extends AccessibilityService {
@@ -39,15 +40,17 @@ public class AccessibilityInsightsForAndroidService extends AccessibilityService
   private ScreenshotController screenshotController = null;
   private int activeWindowId = -1; // Set initial state to an invalid ID
   private FocusVisualizationStateManager focusVisualizationStateManager;
+  private FocusVisualizer focusVisualizer;
+  private FocusVisualizerController focusVisualizerController;
+  private FocusVisualizationCanvas focusVisualizationCanvas;
+  private AccessibilityEventDispatcher accessibilityEventDispatcher;
   private DeviceOrientationHandler deviceOrientationHandler;
 
   public AccessibilityInsightsForAndroidService() {
     deviceConfigFactory = new DeviceConfigFactory();
     axeScanner =
         AxeScannerFactory.createAxeScanner(deviceConfigFactory, this::getRealDisplayMetrics);
     eventHelper = new EventHelper(new ThreadSafeSwapper<>());
-    focusVisualizationStateManager = new FocusVisualizationStateManager();
-    deviceOrientationHandler = new DeviceOrientationHandler(getResources().getConfiguration().orientation);
   }
 
   private DisplayMetrics getRealDisplayMetrics() {
@@ -108,13 +111,31 @@ protected void onServiceConnected() {
 
     StopServerThread();
 
+    WindowManager windowManager = (WindowManager) getSystemService(WINDOW_SERVICE);
+    focusVisualizationStateManager = new FocusVisualizationStateManager();
+    LayoutParamGenerator layoutParamGenerator = new LayoutParamGenerator(this::getRealDisplayMetrics);
+    focusVisualizationCanvas = new FocusVisualizationCanvas(this);
+    focusVisualizer = new FocusVisualizer(new FocusVisualizerStyles(), focusVisualizationCanvas);
+    focusVisualizerController = new FocusVisualizerController(focusVisualizer, focusVisualizationStateManager, new UIThreadRunner(), windowManager, layoutParamGenerator, focusVisualizationCanvas);
+    accessibilityEventDispatcher = new AccessibilityEventDispatcher();
+    deviceOrientationHandler = new DeviceOrientationHandler(getResources().getConfiguration().orientation);
+
+    setupFocusVisualizationListeners();
+
     ResponseThreadFactory responseThreadFactory =
         new ResponseThreadFactory(
             screenshotController, eventHelper, axeScanner, deviceConfigFactory, focusVisualizationStateManager);
     ServerThread = new ServerThread(new ServerSocketFactory(), responseThreadFactory);
     ServerThread.start();
   }
 
+  private void setupFocusVisualizationListeners() {
+    accessibilityEventDispatcher.addOnRedrawEventListener(focusVisualizerController::onRedrawEvent);
+    accessibilityEventDispatcher.addOnFocusEventListener(focusVisualizerController::onFocusEvent);
+    accessibilityEventDispatcher.addOnAppChangedListener(focusVisualizerController::onAppChanged);
+    deviceOrientationHandler.subscribe(focusVisualizerController::onOrientationChanged);
+  }
+
   @Override
   public boolean onUnbind(Intent intent) {
     Logger.logVerbose(TAG, "*** onUnbind");
@@ -126,6 +147,8 @@ public boolean onUnbind(Intent intent) {
 
   @Override
   public void onAccessibilityEvent(AccessibilityEvent event) {
+    accessibilityEventDispatcher.onAccessibilityEvent(event, getRootInActiveWindow());
+
     // This logic ensures that we only track events from the active window, as
     // described under "Retrieving window content" of the Android service docs at
     // https://www.android-doc.com/reference/android/accessibilityservice/AccessibilityService.html

AccessibilityInsightsForAndroidService/app/src/main/java/com/microsoft/accessibilityinsightsforandroidservice/FocusVisualizer.java

@@ -24,27 +24,11 @@ public FocusVisualizer(
     this.focusVisualizationCanvas = focusVisualizationCanvas;
   }
 
-  public void HandleAccessibilityRedrawEvent(AccessibilityEvent event) {
-    if (event.getEventType() == AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED) {
-      return;
-    }
-
-    if (event.getEventType() == AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED) {
-      this.resetVisualizations();
-      return;
-    }
-
-    if (event.getEventType() == AccessibilityEvent.TYPE_VIEW_SCROLLED) {
-      this.updateDrawingsWithNewCoordinates();
-      return;
-    }
-    if (event.getEventType() == AccessibilityEvent.TYPE_WINDOWS_CHANGED) {
-      this.resetVisualizations();
-      return;
-    }
+  public void refreshHighlights() {
+    this.updateDrawingsWithNewCoordinates();
   }
 
-  public void HandleAccessibilityFocusEvent(AccessibilityEvent event) {
+  public void addNewFocusedElement(AccessibilityEvent event) {
     tabStopCount++;
 
     AccessibilityNodeInfo eventSource = event.getSource();
@@ -64,8 +48,10 @@ public void HandleAccessibilityFocusEvent(AccessibilityEvent event) {
     this.setDrawItemsAndRedraw();
   }
 
-  public void setFocusVisualizationCanvas(FocusVisualizationCanvas view) {
-    this.focusVisualizationCanvas = view;
+  public void resetVisualizations() {
+    this.tabStopCount = 0;
+    this.focusElementHighlights.clear();
+    this.focusElementLines.clear();
     this.setDrawItemsAndRedraw();
   }
 
@@ -106,13 +92,6 @@ private AccessibilityNodeInfo getPreviousEventSource() {
     return this.focusElementHighlights.get(this.focusElementHighlights.size() - 1).getEventSource();
   }
 
-  public void resetVisualizations() {
-    this.tabStopCount = 0;
-    this.focusElementHighlights.clear();
-    this.focusElementLines.clear();
-    this.setDrawItemsAndRedraw();
-  }
-
   private void setDrawItemsAndRedraw() {
     this.focusVisualizationCanvas.setDrawItems(this.focusElementHighlights, this.focusElementLines);
     this.focusVisualizationCanvas.redraw();

AccessibilityInsightsForAndroidService/app/src/main/java/com/microsoft/accessibilityinsightsforandroidservice/FocusVisualizerController.java

@@ -3,20 +3,31 @@
 
 package com.microsoft.accessibilityinsightsforandroidservice;
 
+import android.view.WindowManager;
 import android.view.accessibility.AccessibilityEvent;
+import android.view.accessibility.AccessibilityNodeInfo;
 
 public class FocusVisualizerController {
   private FocusVisualizer focusVisualizer;
   private FocusVisualizationStateManager focusVisualizationStateManager;
   private UIThreadRunner uiThreadRunner;
+  private WindowManager windowManager;
+  private LayoutParamGenerator layoutParamGenerator;
+  private FocusVisualizationCanvas focusVisualizationCanvas;
 
   public FocusVisualizerController(
       FocusVisualizer focusVisualizer,
       FocusVisualizationStateManager focusVisualizationStateManager,
-      UIThreadRunner uiThreadRunner) {
+      UIThreadRunner uiThreadRunner,
+      WindowManager windowManager,
+      LayoutParamGenerator layoutParamGenerator,
+      FocusVisualizationCanvas focusVisualizationCanvas) {
     this.focusVisualizer = focusVisualizer;
     this.focusVisualizationStateManager = focusVisualizationStateManager;
     this.uiThreadRunner = uiThreadRunner;
+    this.windowManager = windowManager;
+    this.layoutParamGenerator = layoutParamGenerator;
+    this.focusVisualizationCanvas = focusVisualizationCanvas;
     this.focusVisualizationStateManager.subscribe(this::onFocusVisualizationStateChange);
   }
 
@@ -25,22 +36,48 @@ public void onFocusEvent(AccessibilityEvent event) {
       return;
     }
 
-    focusVisualizer.HandleAccessibilityFocusEvent(event);
+    focusVisualizer.addNewFocusedElement(event);
   }
 
   public void onRedrawEvent(AccessibilityEvent event) {
     if (focusVisualizationStateManager.getState() == false) {
       return;
     }
 
-    focusVisualizer.HandleAccessibilityRedrawEvent(event);
+    focusVisualizer.refreshHighlights();
   }
 
-  private void onFocusVisualizationStateChange(boolean newState) {
-    if (newState) {
+  public void onAppChanged(AccessibilityNodeInfo nodeInfo) {
+    if (focusVisualizationStateManager.getState() == false) {
+      return;
+    }
+
+    focusVisualizer.resetVisualizations();
+  }
+
+  public void onOrientationChanged(Integer orientation) {
+    if (focusVisualizationStateManager.getState() == false) {
       return;
     }
 
-    uiThreadRunner.run(focusVisualizer::resetVisualizations);
+    windowManager.updateViewLayout(focusVisualizationCanvas, layoutParamGenerator.get());
+    focusVisualizer.resetVisualizations();
+  }
+
+  private void onFocusVisualizationStateChange(boolean enabled) {
+    if (enabled) {
+      uiThreadRunner.run(this::addFocusVisualizationToScreen);
+    } else {
+      uiThreadRunner.run(this::removeFocusVisualizationToScreen);
+    }
+  }
+
+  private void addFocusVisualizationToScreen() {
+    windowManager.addView(focusVisualizationCanvas, layoutParamGenerator.get());
+  }
+
+  private void removeFocusVisualizationToScreen() {
+    focusVisualizer.resetVisualizations();
+    windowManager.removeView(focusVisualizationCanvas);
   }
 }

AccessibilityInsightsForAndroidService/app/src/test/java/com/microsoft/accessibilityinsightsforandroidservice/AccessibilityEventDispatcherTest.java

@@ -53,6 +53,17 @@ public void onAppChangedFiresWithoutPreviousPackageName() {
     verify(onAppChangedListenerMock, times(1)).accept(rootNodeMock);
   }
 
+  @Test
+  public void onAppChangedDoesNotFireWhenRootNodeIsNull() {
+    int trivialEventType = -1;
+    when(eventMock.getEventType()).thenReturn(trivialEventType);
+
+    testSubject.addOnAppChangedListener(onAppChangedListenerMock);
+    testSubject.onAccessibilityEvent(eventMock, null);
+
+    verify(onAppChangedListenerMock, times(0)).accept(rootNodeMock);
+  }
+
   @Test
   public void onAppChangedFiresWhenPackageNameChanged() {
     int trivialEventType = -1;
@@ -103,7 +114,7 @@ public void onRedrawEventListenerFiresOnRedrawEvents() {
           reset(eventMock);
         });
 
-    verify(onRedrawEventListenerMock, times(4)).accept(eventMock);
+    verify(onRedrawEventListenerMock, times(3)).accept(eventMock);
   }
 
   @Test