server/accessibility/AbstractAccessibilityServiceConnectionTest.java

/*
 * Copyright (C) 2019 The Android Open Source Project
 *
 * 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.
 */

package com.android.server.accessibility;

import static android.accessibilityservice.AccessibilityService.ERROR_TAKE_SCREENSHOT_INVALID_DISPLAY;
import static android.accessibilityservice.AccessibilityService.ERROR_TAKE_SCREENSHOT_NO_ACCESSIBILITY_ACCESS;
import static android.accessibilityservice.AccessibilityService.GLOBAL_ACTION_HOME;
import static android.accessibilityservice.AccessibilityService.KEY_ACCESSIBILITY_SCREENSHOT_STATUS;
import static android.accessibilityservice.AccessibilityServiceInfo.CAPABILITY_CAN_CONTROL_MAGNIFICATION;
import static android.accessibilityservice.AccessibilityServiceInfo.CAPABILITY_CAN_PERFORM_GESTURES;
import static android.accessibilityservice.AccessibilityServiceInfo.CAPABILITY_CAN_REQUEST_FILTER_KEY_EVENTS;
import static android.accessibilityservice.AccessibilityServiceInfo.CAPABILITY_CAN_REQUEST_TOUCH_EXPLORATION;
import static android.accessibilityservice.AccessibilityServiceInfo.CAPABILITY_CAN_RETRIEVE_WINDOW_CONTENT;
import static android.accessibilityservice.AccessibilityServiceInfo.DEFAULT;
import static android.accessibilityservice.AccessibilityServiceInfo.FEEDBACK_HAPTIC;
import static android.accessibilityservice.AccessibilityServiceInfo.FEEDBACK_SPOKEN;
import static android.accessibilityservice.AccessibilityServiceInfo.FLAG_INCLUDE_NOT_IMPORTANT_VIEWS;
import static android.accessibilityservice.AccessibilityServiceInfo.FLAG_REPORT_VIEW_IDS;
import static android.accessibilityservice.AccessibilityServiceInfo.FLAG_REQUEST_ACCESSIBILITY_BUTTON;
import static android.accessibilityservice.AccessibilityServiceInfo.FLAG_REQUEST_FILTER_KEY_EVENTS;
import static android.accessibilityservice.AccessibilityServiceInfo.FLAG_REQUEST_FINGERPRINT_GESTURES;
import static android.accessibilityservice.AccessibilityServiceInfo.FLAG_REQUEST_TOUCH_EXPLORATION_MODE;
import static android.accessibilityservice.AccessibilityServiceInfo.FLAG_RETRIEVE_INTERACTIVE_WINDOWS;
import static android.content.pm.PackageManager.FEATURE_FINGERPRINT;
import static android.view.View.FOCUS_DOWN;
import static android.view.accessibility.AccessibilityEvent.TYPE_VIEW_CLICKED;
import static android.view.accessibility.AccessibilityEvent.TYPE_VIEW_LONG_CLICKED;
import static android.view.accessibility.AccessibilityNodeInfo.ACTION_ACCESSIBILITY_FOCUS;
import static android.view.accessibility.AccessibilityNodeInfo.ACTION_CLICK;
import static android.view.accessibility.AccessibilityNodeInfo.ACTION_LONG_CLICK;
import static android.view.accessibility.AccessibilityNodeInfo.AccessibilityAction;
import static android.view.accessibility.AccessibilityNodeInfo.FOCUS_INPUT;
import static android.view.accessibility.AccessibilityNodeInfo.ROOT_NODE_ID;

import static org.hamcrest.Matchers.hasItems;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.nullValue;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;

import android.accessibilityservice.AccessibilityService;
import android.accessibilityservice.AccessibilityServiceInfo;
import android.accessibilityservice.AccessibilityTrace;
import android.accessibilityservice.IAccessibilityServiceClient;
import android.accessibilityservice.MagnificationConfig;
import android.content.ComponentName;
import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.content.pm.ServiceInfo;
import android.graphics.Region;
import android.hardware.display.DisplayManager;
import android.os.Build;
import android.os.Handler;
import android.os.IBinder;
import android.os.IPowerManager;
import android.os.IThermalService;
import android.os.PowerManager;
import android.os.Process;
import android.os.RemoteCallback;
import android.os.RemoteException;
import android.util.Pair;
import android.view.Display;
import android.view.KeyEvent;
import android.view.MagnificationSpec;
import android.view.accessibility.AccessibilityNodeInfo;
import android.view.accessibility.AccessibilityWindowInfo;
import android.view.accessibility.IAccessibilityInteractionConnection;
import android.view.accessibility.IAccessibilityInteractionConnectionCallback;

import com.android.server.accessibility.AccessibilityWindowManager.RemoteAccessibilityConnection;
import com.android.server.accessibility.magnification.MagnificationProcessor;
import com.android.server.accessibility.test.MessageCapturingHandler;
import com.android.server.wm.WindowManagerInternal;

import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.Spy;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.Callable;

/**
 * Tests for the AbstractAccessibilityServiceConnection
 */
public class AbstractAccessibilityServiceConnectionTest {
    private static final ComponentName COMPONENT_NAME = new ComponentName(
            "com.android.server.accessibility", ".AbstractAccessibilityServiceConnectionTest");
    private static final String PACKAGE_NAME1 = "com.android.server.accessibility1";
    private static final String PACKAGE_NAME2 = "com.android.server.accessibility2";
    private static final String VIEWID_RESOURCE_NAME = "test_viewid_resource_name";
    private static final String VIEW_TEXT = "test_view_text";
    private static final int WINDOWID = 12;
    private static final int PIP_WINDOWID = 13;
    private static final int WINDOWID_ONSECONDDISPLAY = 14;
    private static final int SECONDARY_DISPLAY_ID = Display.DEFAULT_DISPLAY + 1;
    private static final int SERVICE_ID = 42;
    private static final int A11Y_SERVICE_CAPABILITY = CAPABILITY_CAN_RETRIEVE_WINDOW_CONTENT
            | CAPABILITY_CAN_REQUEST_TOUCH_EXPLORATION
            | CAPABILITY_CAN_REQUEST_FILTER_KEY_EVENTS
            | CAPABILITY_CAN_CONTROL_MAGNIFICATION
            | CAPABILITY_CAN_PERFORM_GESTURES;
    private static final int A11Y_SERVICE_FLAG = DEFAULT
            | FLAG_INCLUDE_NOT_IMPORTANT_VIEWS
            | FLAG_REPORT_VIEW_IDS
            | FLAG_REQUEST_TOUCH_EXPLORATION_MODE
            | FLAG_REQUEST_FILTER_KEY_EVENTS
            | FLAG_REQUEST_FINGERPRINT_GESTURES
            | FLAG_REQUEST_ACCESSIBILITY_BUTTON
            | FLAG_RETRIEVE_INTERACTIVE_WINDOWS;
    private static final int USER_ID = 1;
    private static final int USER_ID2 = 2;
    private static final int INTERACTION_ID = 199;
    private static final Pair<float[], MagnificationSpec> FAKE_MATRIX_AND_MAG_SPEC =
            new Pair<>(new float[9], new MagnificationSpec());
    private static final int PID = Process.myPid();
    private static final long TID = Process.myTid();
    private static final int UID = Process.myUid();

    private AbstractAccessibilityServiceConnection mServiceConnection;
    private MessageCapturingHandler mHandler = new MessageCapturingHandler(null);
    private final List<AccessibilityWindowInfo> mA11yWindowInfos = new ArrayList<>();
    private final List<AccessibilityWindowInfo> mA11yWindowInfosOnSecondDisplay = new ArrayList<>();
    private Callable[] mFindA11yNodesFunctions;
    private Callable<Boolean> mPerformA11yAction;
    private ArrayList<Integer> mDisplayList = new ArrayList<>(Arrays.asList(
            Display.DEFAULT_DISPLAY, SECONDARY_DISPLAY_ID));

    @Mock private Context mMockContext;
    @Mock private IPowerManager mMockIPowerManager;
    @Mock private IThermalService mMockIThermalService;
    @Mock private PackageManager mMockPackageManager;
    @Spy  private AccessibilityServiceInfo mSpyServiceInfo = new AccessibilityServiceInfo();
    @Mock private AccessibilitySecurityPolicy mMockSecurityPolicy;
    @Mock private AccessibilityWindowManager mMockA11yWindowManager;
    @Mock private AbstractAccessibilityServiceConnection.SystemSupport mMockSystemSupport;
    @Mock private AccessibilityTrace mMockA11yTrace;
    @Mock private WindowManagerInternal mMockWindowManagerInternal;
    @Mock private SystemActionPerformer mMockSystemActionPerformer;
    @Mock private IBinder mMockService;
    @Mock private IAccessibilityServiceClient mMockServiceInterface;
    @Mock private KeyEventDispatcher mMockKeyEventDispatcher;
    @Mock private IAccessibilityInteractionConnection mMockIA11yInteractionConnection;
    @Mock private IAccessibilityInteractionConnectionCallback mMockCallback;
    @Mock private FingerprintGestureDispatcher mMockFingerprintGestureDispatcher;
    @Mock private MagnificationProcessor mMockMagnificationProcessor;
    @Mock private RemoteCallback.OnResultListener mMockListener;

    @Before
    public void setup() {
        MockitoAnnotations.initMocks(this);

        when(mMockSystemSupport.getCurrentUserIdLocked()).thenReturn(USER_ID);
        when(mMockSystemSupport.getKeyEventDispatcher()).thenReturn(mMockKeyEventDispatcher);
        when(mMockSystemSupport.getFingerprintGestureDispatcher())
                .thenReturn(mMockFingerprintGestureDispatcher);
        when(mMockSystemSupport.getMagnificationProcessor())
                .thenReturn(mMockMagnificationProcessor);
        when(mMockSystemSupport.getWindowTransformationMatrixAndMagnificationSpec(anyInt()))
                .thenReturn(FAKE_MATRIX_AND_MAG_SPEC);

        PowerManager powerManager =
                new PowerManager(mMockContext, mMockIPowerManager, mMockIThermalService, mHandler);
        when(mMockContext.getSystemService(Context.POWER_SERVICE)).thenReturn(powerManager);
        when(mMockContext.getPackageManager()).thenReturn(mMockPackageManager);
        when(mMockPackageManager.hasSystemFeature(FEATURE_FINGERPRINT)).thenReturn(true);

        when(mMockA11yTrace.isA11yTracingEnabled()).thenReturn(false);
        // Fake a11yWindowInfo and remote a11y connection for tests.
        addA11yWindowInfo(mA11yWindowInfos, WINDOWID, false, Display.DEFAULT_DISPLAY);
        addA11yWindowInfo(mA11yWindowInfos, PIP_WINDOWID, true, Display.DEFAULT_DISPLAY);
        addA11yWindowInfo(mA11yWindowInfosOnSecondDisplay, WINDOWID_ONSECONDDISPLAY, false,
                SECONDARY_DISPLAY_ID);
        when(mMockA11yWindowManager.getDisplayListLocked(anyInt())).thenReturn(mDisplayList);
        when(mMockA11yWindowManager.getWindowListLocked(Display.DEFAULT_DISPLAY))
                .thenReturn(mA11yWindowInfos);
        when(mMockA11yWindowManager.findA11yWindowInfoByIdLocked(WINDOWID))
                .thenReturn(mA11yWindowInfos.get(0));
        when(mMockA11yWindowManager.findA11yWindowInfoByIdLocked(PIP_WINDOWID))
                .thenReturn(mA11yWindowInfos.get(1));
        when(mMockA11yWindowManager.getDisplayIdByUserIdAndWindowIdLocked(USER_ID,
            WINDOWID_ONSECONDDISPLAY)).thenReturn(SECONDARY_DISPLAY_ID);
        when(mMockA11yWindowManager.getWindowListLocked(SECONDARY_DISPLAY_ID))
            .thenReturn(mA11yWindowInfosOnSecondDisplay);
        when(mMockA11yWindowManager.findA11yWindowInfoByIdLocked(WINDOWID_ONSECONDDISPLAY))
            .thenReturn(mA11yWindowInfosOnSecondDisplay.get(0));
        final RemoteAccessibilityConnection conn = getRemoteA11yConnection(
                WINDOWID, mMockIA11yInteractionConnection, PACKAGE_NAME1);
        final RemoteAccessibilityConnection connPip = getRemoteA11yConnection(
                PIP_WINDOWID, mMockIA11yInteractionConnection, PACKAGE_NAME2);
        when(mMockA11yWindowManager.getConnectionLocked(USER_ID, WINDOWID)).thenReturn(conn);
        when(mMockA11yWindowManager.getConnectionLocked(USER_ID, PIP_WINDOWID)).thenReturn(connPip);
        when(mMockA11yWindowManager.getPictureInPictureActionReplacingConnection())
                .thenReturn(connPip);

        // Update a11yServiceInfo to full capability, full flags and target sdk jelly bean
        final ResolveInfo mockResolveInfo = mock(ResolveInfo.class);
        mockResolveInfo.serviceInfo = mock(ServiceInfo.class);
        mockResolveInfo.serviceInfo.applicationInfo = mock(ApplicationInfo.class);
        mockResolveInfo.serviceInfo.applicationInfo.targetSdkVersion =
                Build.VERSION_CODES.JELLY_BEAN;
        doReturn(mockResolveInfo).when(mSpyServiceInfo).getResolveInfo();
        mSpyServiceInfo.setCapabilities(A11Y_SERVICE_CAPABILITY);
        updateServiceInfo(mSpyServiceInfo, 0, 0, A11Y_SERVICE_FLAG, null, 0);

        mServiceConnection = new TestAccessibilityServiceConnection(mMockContext, COMPONENT_NAME,
                mSpyServiceInfo, SERVICE_ID, mHandler, new Object(), mMockSecurityPolicy,
                mMockSystemSupport, mMockA11yTrace, mMockWindowManagerInternal,
                mMockSystemActionPerformer, mMockA11yWindowManager);
        // Assume that the service is connected
        mServiceConnection.mService = mMockService;
        mServiceConnection.mServiceInterface = mMockServiceInterface;

        // Update security policy for this service
        when(mMockSecurityPolicy.checkAccessibilityAccess(mServiceConnection)).thenReturn(true);
        when(mMockSecurityPolicy.canRetrieveWindowsLocked(mServiceConnection)).thenReturn(true);
        when(mMockSecurityPolicy.canGetAccessibilityNodeInfoLocked(
                eq(USER_ID), eq(mServiceConnection), anyInt())).thenReturn(true);
        when(mMockSecurityPolicy.canControlMagnification(mServiceConnection)).thenReturn(true);

        // init test functions for accessAccessibilityNodeInfo test case.
        initTestFunctions();
    }

    @Test
    public void getCapabilities() {
        assertThat(mServiceConnection.getCapabilities(), is(A11Y_SERVICE_CAPABILITY));
    }

    @Test
    public void onKeyEvent() throws RemoteException {
        final int sequenceNumber = 100;
        final KeyEvent mockKeyEvent = mock(KeyEvent.class);

        mServiceConnection.onKeyEvent(mockKeyEvent, sequenceNumber);
        verify(mMockServiceInterface).onKeyEvent(mockKeyEvent, sequenceNumber);
    }

    @Test
    public void setServiceInfo_invokeOnClientChange() {
        final AccessibilityServiceInfo serviceInfo = new AccessibilityServiceInfo();
        updateServiceInfo(serviceInfo,
                TYPE_VIEW_CLICKED | TYPE_VIEW_LONG_CLICKED,
                FEEDBACK_SPOKEN | FEEDBACK_HAPTIC,
                A11Y_SERVICE_FLAG,
                new String[] {PACKAGE_NAME1, PACKAGE_NAME2},
                1000);

        mServiceConnection.setServiceInfo(serviceInfo);
        verify(mMockSystemSupport).onClientChangeLocked(true);
    }

    @Test
    public void setServiceInfo_ChangePackageNames_updateSuccess() {
        assertTrue(mServiceConnection.mPackageNames.isEmpty());

        final AccessibilityServiceInfo serviceInfo = new AccessibilityServiceInfo();
        updateServiceInfo(serviceInfo, 0, 0, A11Y_SERVICE_FLAG,
                new String[] {PACKAGE_NAME1, PACKAGE_NAME2},
                1000);

        mServiceConnection.setServiceInfo(serviceInfo);
        assertEquals(serviceInfo.packageNames.length, mServiceConnection.mPackageNames.size());
        assertTrue(mServiceConnection.mPackageNames.containsAll(
                Arrays.asList(mServiceConnection.getServiceInfo().packageNames)));

        updateServiceInfo(serviceInfo, 0, 0, A11Y_SERVICE_FLAG, null, 1000);
        mServiceConnection.setServiceInfo(serviceInfo);
        assertTrue(mServiceConnection.mPackageNames.isEmpty());
    }

    @Test
    public void setServiceInfo_ChangeAccessibilityTool_updateFails() {
        assertFalse(mSpyServiceInfo.isAccessibilityTool());

        final AccessibilityServiceInfo serviceInfo = new AccessibilityServiceInfo();
        serviceInfo.setAccessibilityTool(true);
        mServiceConnection.setServiceInfo(serviceInfo);

        // isAccessibilityTool should not be dynamically updatable
        assertFalse(mSpyServiceInfo.isAccessibilityTool());
    }

    @Test
    public void canReceiveEvents_hasEventType_returnTrue() {
        final AccessibilityServiceInfo serviceInfo = new AccessibilityServiceInfo();
        updateServiceInfo(serviceInfo,
                TYPE_VIEW_CLICKED | TYPE_VIEW_LONG_CLICKED, 0,
                0, null, 0);

        mServiceConnection.setServiceInfo(serviceInfo);
        assertThat(mServiceConnection.canReceiveEventsLocked(), is(true));
    }

    @Test
    public void setOnKeyEventResult() {
        final int sequenceNumber = 100;
        final boolean handled = true;
        mServiceConnection.setOnKeyEventResult(handled, sequenceNumber);

        verify(mMockKeyEventDispatcher).setOnKeyEventResult(
                mServiceConnection, handled, sequenceNumber);
    }

    @Test
    public void getWindows() {
        final AccessibilityWindowInfo.WindowListSparseArray allWindows =
                mServiceConnection.getWindows();

        assertEquals(2, allWindows.size());
        assertThat(allWindows.get(Display.DEFAULT_DISPLAY), is(mA11yWindowInfos));
        assertEquals(2, allWindows.get(Display.DEFAULT_DISPLAY).size());
        assertThat(allWindows.get(SECONDARY_DISPLAY_ID), is(mA11yWindowInfosOnSecondDisplay));
        assertEquals(1, allWindows.get(SECONDARY_DISPLAY_ID).size());
    }

    @Test
    public void getWindows_returnNull() {
        // no canRetrieveWindows, should return null
        when(mMockSecurityPolicy.canRetrieveWindowsLocked(mServiceConnection)).thenReturn(false);
        assertThat(mServiceConnection.getWindows(), is(nullValue()));

        // no checkAccessibilityAccess, should return null
        when(mMockSecurityPolicy.canRetrieveWindowsLocked(mServiceConnection)).thenReturn(true);
        when(mMockSecurityPolicy.checkAccessibilityAccess(mServiceConnection)).thenReturn(false);
        assertThat(mServiceConnection.getWindows(), is(nullValue()));
    }

    @Test
    public void getWindows_notTrackingWindows_invokeOnClientChange() {
        when(mMockA11yWindowManager.getWindowListLocked(Display.DEFAULT_DISPLAY)).thenReturn(null);
        when(mMockA11yWindowManager.isTrackingWindowsLocked(Display.DEFAULT_DISPLAY))
                .thenReturn(false);

        mServiceConnection.getWindows();
        verify(mMockSystemSupport).onClientChangeLocked(false);
    }

    @Test
    public void getWindow() {
        assertThat(mServiceConnection.getWindow(WINDOWID), is(mA11yWindowInfos.get(0)));
    }

    @Test
    public void getWindow_returnNull() {
        // no canRetrieveWindows, should return null
        when(mMockSecurityPolicy.canRetrieveWindowsLocked(mServiceConnection)).thenReturn(false);
        assertThat(mServiceConnection.getWindow(WINDOWID), is(nullValue()));

        // no checkAccessibilityAccess, should return null
        when(mMockSecurityPolicy.canRetrieveWindowsLocked(mServiceConnection)).thenReturn(true);
        when(mMockSecurityPolicy.checkAccessibilityAccess(mServiceConnection)).thenReturn(false);
        assertThat(mServiceConnection.getWindow(WINDOWID), is(nullValue()));
    }

    @Test
    public void getWindow_notTrackingWindows_invokeOnClientChange() {
        when(mMockA11yWindowManager.getWindowListLocked(Display.DEFAULT_DISPLAY)).thenReturn(null);
        when(mMockA11yWindowManager.isTrackingWindowsLocked(Display.DEFAULT_DISPLAY))
                .thenReturn(false);

        mServiceConnection.getWindow(WINDOWID);
        verify(mMockSystemSupport).onClientChangeLocked(false);
    }

    @Test
    public void getWindow_onNonDefaultDisplay() {
        assertThat(mServiceConnection.getWindow(WINDOWID_ONSECONDDISPLAY),
                is(mA11yWindowInfosOnSecondDisplay.get(0)));
    }

    @Test
    public void accessAccessibilityNodeInfo_whenCantGetInfo_returnNullOrFalse()
            throws Exception {
        when(mMockSecurityPolicy.canGetAccessibilityNodeInfoLocked(
                USER_ID, mServiceConnection, WINDOWID)).thenReturn(false);
        for (int i = 0; i < mFindA11yNodesFunctions.length; i++) {
            assertThat(mFindA11yNodesFunctions[i].call(), is(nullValue()));
        }
        assertThat(mPerformA11yAction.call(), is(false));

        verifyNoMoreInteractions(mMockIA11yInteractionConnection);
        verify(mMockSecurityPolicy, never()).computeValidReportedPackages(any(), anyInt());
    }

    @Test
    public void accessAccessibilityNodeInfo_whenNoA11yAccess_returnNullOrFalse()
            throws Exception {
        when(mMockSecurityPolicy.checkAccessibilityAccess(mServiceConnection)).thenReturn(false);
        for (int i = 0; i < mFindA11yNodesFunctions.length; i++) {
            assertThat(mFindA11yNodesFunctions[i].call(), is(nullValue()));
        }
        assertThat(mPerformA11yAction.call(), is(false));

        verifyNoMoreInteractions(mMockIA11yInteractionConnection);
        verify(mMockSecurityPolicy, never()).computeValidReportedPackages(any(), anyInt());
    }

    @Test
    public void accessAccessibilityNodeInfo_whenNoRemoteA11yConnection_returnNullOrFalse()
            throws Exception {
        when(mMockA11yWindowManager.getConnectionLocked(USER_ID, WINDOWID)).thenReturn(null);
        for (int i = 0; i < mFindA11yNodesFunctions.length; i++) {
            assertThat(mFindA11yNodesFunctions[i].call(), is(nullValue()));
        }
        assertThat(mPerformA11yAction.call(), is(false));

        verifyNoMoreInteractions(mMockIA11yInteractionConnection);
        verify(mMockSecurityPolicy, never()).computeValidReportedPackages(any(), anyInt());
    }

    @Test
    public void findAccessibilityNodeInfosByViewId_withPipWindow_shouldReplaceCallback()
            throws RemoteException {
        final ArgumentCaptor<IAccessibilityInteractionConnectionCallback> captor =
                ArgumentCaptor.forClass(IAccessibilityInteractionConnectionCallback.class);
        mServiceConnection.findAccessibilityNodeInfosByViewId(PIP_WINDOWID, ROOT_NODE_ID,
                VIEWID_RESOURCE_NAME, INTERACTION_ID, mMockCallback, TID);
        verify(mMockIA11yInteractionConnection).findAccessibilityNodeInfosByViewId(
                eq(ROOT_NODE_ID), eq(VIEWID_RESOURCE_NAME), any(), eq(INTERACTION_ID),
                captor.capture(), anyInt(), eq(PID), eq(TID), any(), nullable(float[].class));
        verify(mMockSecurityPolicy).computeValidReportedPackages(any(), anyInt());
        verifyReplaceActions(captor.getValue());
    }

    @Test
    public void findAccessibilityNodeInfosByText_withPipWindow_shouldReplaceCallback()
            throws RemoteException {
        final ArgumentCaptor<IAccessibilityInteractionConnectionCallback> captor =
                ArgumentCaptor.forClass(IAccessibilityInteractionConnectionCallback.class);
        mServiceConnection.findAccessibilityNodeInfosByText(PIP_WINDOWID, ROOT_NODE_ID,
                VIEW_TEXT, INTERACTION_ID, mMockCallback, TID);
        verify(mMockIA11yInteractionConnection).findAccessibilityNodeInfosByText(
                eq(ROOT_NODE_ID), eq(VIEW_TEXT), any(), eq(INTERACTION_ID),
                captor.capture(), anyInt(), eq(PID), eq(TID), any(), nullable(float[].class));
        verify(mMockSecurityPolicy).computeValidReportedPackages(any(), anyInt());
        verifyReplaceActions(captor.getValue());
    }

    @Test
    public void findAccessibilityNodeInfoByAccessibilityId_withPipWindow_shouldReplaceCallback()
            throws RemoteException {
        final ArgumentCaptor<IAccessibilityInteractionConnectionCallback> captor =
                ArgumentCaptor.forClass(IAccessibilityInteractionConnectionCallback.class);
        mServiceConnection.findAccessibilityNodeInfoByAccessibilityId(PIP_WINDOWID, ROOT_NODE_ID,
                INTERACTION_ID, mMockCallback, 0, TID, null);
        verify(mMockIA11yInteractionConnection).findAccessibilityNodeInfoByAccessibilityId(
                eq(ROOT_NODE_ID), any(), eq(INTERACTION_ID), captor.capture(), anyInt(),
                eq(PID), eq(TID), any(),  nullable(float[].class), any());
        verify(mMockSecurityPolicy).computeValidReportedPackages(any(), anyInt());
        verifyReplaceActions(captor.getValue());
    }

    @Test
    public void findFocus_withPipWindow_shouldReplaceCallback()
            throws RemoteException {
        final ArgumentCaptor<IAccessibilityInteractionConnectionCallback> captor =
                ArgumentCaptor.forClass(IAccessibilityInteractionConnectionCallback.class);
        mServiceConnection.findFocus(PIP_WINDOWID, ROOT_NODE_ID, FOCUS_INPUT, INTERACTION_ID,
                mMockCallback, TID);
        verify(mMockIA11yInteractionConnection).findFocus(eq(ROOT_NODE_ID), eq(FOCUS_INPUT),
                any(), eq(INTERACTION_ID), captor.capture(), anyInt(), eq(PID), eq(TID), any(),
                nullable(float[].class));
        verify(mMockSecurityPolicy).computeValidReportedPackages(any(), anyInt());
        verifyReplaceActions(captor.getValue());
    }

    @Test
    public void focusSearch_withPipWindow_shouldReplaceCallback()
            throws RemoteException {
        final ArgumentCaptor<IAccessibilityInteractionConnectionCallback> captor =
                ArgumentCaptor.forClass(IAccessibilityInteractionConnectionCallback.class);
        mServiceConnection.focusSearch(PIP_WINDOWID, ROOT_NODE_ID, FOCUS_DOWN, INTERACTION_ID,
                mMockCallback, TID);
        verify(mMockIA11yInteractionConnection).focusSearch(eq(ROOT_NODE_ID), eq(FOCUS_DOWN),
                any(), eq(INTERACTION_ID), captor.capture(), anyInt(), eq(PID), eq(TID), any(),
                nullable(float[].class));
        verify(mMockSecurityPolicy).computeValidReportedPackages(any(), anyInt());
        verifyReplaceActions(captor.getValue());
    }

    @Test
    public void performAccessibilityAction_withPipWindow_invokeGetPipReplacingConnection()
            throws RemoteException {
        mServiceConnection.performAccessibilityAction(PIP_WINDOWID, ROOT_NODE_ID,
                ACTION_ACCESSIBILITY_FOCUS, null, INTERACTION_ID, mMockCallback, TID);

        verify(mMockIPowerManager).userActivity(eq(Display.DEFAULT_DISPLAY), anyLong(), anyInt(),
                anyInt());
        verify(mMockIA11yInteractionConnection).performAccessibilityAction(eq(ROOT_NODE_ID),
                eq(ACTION_ACCESSIBILITY_FOCUS), any(), eq(INTERACTION_ID), eq(mMockCallback),
                anyInt(), eq(PID), eq(TID));
        verify(mMockA11yWindowManager).getPictureInPictureActionReplacingConnection();
    }

    @Test
    public void performAccessibilityAction_withClick_shouldNotifyOutsideTouch()
            throws RemoteException {
        mServiceConnection.performAccessibilityAction(WINDOWID, ROOT_NODE_ID,
                ACTION_CLICK, null, INTERACTION_ID, mMockCallback, TID);
        mServiceConnection.performAccessibilityAction(PIP_WINDOWID, ROOT_NODE_ID,
                ACTION_LONG_CLICK, null, INTERACTION_ID, mMockCallback, TID);
        verify(mMockA11yWindowManager).notifyOutsideTouch(eq(USER_ID), eq(WINDOWID));
        verify(mMockA11yWindowManager).notifyOutsideTouch(eq(USER_ID), eq(PIP_WINDOWID));
    }

    @Test
    public void performGlobalAction() {
        mServiceConnection.performGlobalAction(GLOBAL_ACTION_HOME);
        verify(mMockSystemActionPerformer).performSystemAction(GLOBAL_ACTION_HOME);
    }

    @Test
    public void getSystemActions() {
        List<AccessibilityNodeInfo.AccessibilityAction> actions =
                mServiceConnection.getSystemActions();
        verify(mMockSystemActionPerformer).getSystemActions();
    }

    @Test
    public void isFingerprintGestureDetectionAvailable_hasFingerPrintSupport_returnTrue() {
        when(mMockFingerprintGestureDispatcher.isFingerprintGestureDetectionAvailable())
                .thenReturn(true);
        final boolean result = mServiceConnection.isFingerprintGestureDetectionAvailable();
        assertThat(result, is(true));
    }

    @Test
    public void isFingerprintGestureDetectionAvailable_noFingerPrintSupport_returnFalse() {
        when(mMockFingerprintGestureDispatcher.isFingerprintGestureDetectionAvailable())
                .thenReturn(true);

        // Return false if device does not support fingerprint
        when(mMockPackageManager.hasSystemFeature(FEATURE_FINGERPRINT)).thenReturn(false);
        boolean result = mServiceConnection.isFingerprintGestureDetectionAvailable();
        assertThat(result, is(false));

        // Return false if service does not have flag
        when(mMockPackageManager.hasSystemFeature(FEATURE_FINGERPRINT)).thenReturn(true);
        mSpyServiceInfo.flags = A11Y_SERVICE_FLAG & ~FLAG_REQUEST_FINGERPRINT_GESTURES;
        mServiceConnection.setServiceInfo(mSpyServiceInfo);
        result = mServiceConnection.isFingerprintGestureDetectionAvailable();
        assertThat(result, is(false));
    }

    @Test
    public void getMagnificationScale() {
        final int displayId = 1;
        final float scale = 2.0f;
        when(mMockMagnificationProcessor.getScale(displayId)).thenReturn(scale);

        final float result = mServiceConnection.getMagnificationScale(displayId);
        assertThat(result, is(scale));
    }

    @Test
    public void getMagnificationScale_serviceNotBelongCurrentUser_returnNoScale() {
        final int displayId = 1;
        final float scale = 2.0f;
        when(mMockMagnificationProcessor.getScale(displayId)).thenReturn(scale);
        when(mMockSystemSupport.getCurrentUserIdLocked()).thenReturn(USER_ID2);

        final float result = mServiceConnection.getMagnificationScale(displayId);
        assertThat(result, is(1.0f));
    }

    @Test
    public void getMagnificationRegion_serviceNotBelongCurrentUser_returnEmptyRegion() {
        final int displayId = 1;
        final Region region = new Region(10, 20, 100, 200);
        doAnswer((invocation) -> {
            ((Region) invocation.getArguments()[1]).set(region);
            return null;
        }).when(mMockMagnificationProcessor).getFullscreenMagnificationRegion(eq(displayId), any(),
                anyBoolean());
        when(mMockSystemSupport.getCurrentUserIdLocked()).thenReturn(USER_ID2);

        final Region result = mServiceConnection.getMagnificationRegion(displayId);
        assertThat(result.isEmpty(), is(true));
    }

    @Test
    public void getCurrentMagnificationRegion_returnRegion() {
        final int displayId = 1;
        final Region region = new Region(10, 20, 100, 200);
        doAnswer((invocation) -> {
            ((Region) invocation.getArguments()[1]).set(region);
            return null;
        }).when(mMockMagnificationProcessor).getCurrentMagnificationRegion(eq(displayId), any(),
                anyBoolean());

        final Region result = mServiceConnection.getCurrentMagnificationRegion(displayId);
        assertEquals(result, region);
    }

    @Test
    public void getMagnificationCenterX_serviceNotBelongCurrentUser_returnZero() {
        final int displayId = 1;
        final float centerX = 480.0f;
        when(mMockMagnificationProcessor.getCenterX(displayId, /* canControlMagnification= */
                true)).thenReturn(centerX);
        when(mMockSystemSupport.getCurrentUserIdLocked()).thenReturn(USER_ID2);

        final float result = mServiceConnection.getMagnificationCenterX(displayId);
        assertThat(result, is(0.0f));
    }

    @Test
    public void getMagnificationCenterY_serviceNotBelongCurrentUser_returnZero() {
        final int displayId = 1;
        final float centerY = 640.0f;
        when(mMockMagnificationProcessor.getCenterY(displayId, /* canControlMagnification= */
                true)).thenReturn(centerY);
        when(mMockSystemSupport.getCurrentUserIdLocked()).thenReturn(USER_ID2);

        final float result = mServiceConnection.getMagnificationCenterY(displayId);
        assertThat(result, is(0.0f));
    }

    @Test
    public void resetMagnification() {
        final int displayId = 1;
        when(mMockMagnificationProcessor.resetFullscreenMagnification(displayId, true)).thenReturn(
                true);

        final boolean result = mServiceConnection.resetMagnification(displayId, true);
        assertThat(result, is(true));
    }

    @Test
    public void resetMagnification_cantControlMagnification_returnFalse() {
        final int displayId = 1;
        when(mMockMagnificationProcessor.resetFullscreenMagnification(displayId, true)).thenReturn(
                true);
        when(mMockSecurityPolicy.canControlMagnification(mServiceConnection)).thenReturn(false);

        final boolean result = mServiceConnection.resetMagnification(displayId, true);
        assertThat(result, is(false));
    }

    @Test
    public void resetMagnification_serviceNotBelongCurrentUser_returnFalse() {
        final int displayId = 1;
        when(mMockMagnificationProcessor.resetFullscreenMagnification(displayId, true)).thenReturn(
                true);
        when(mMockSystemSupport.getCurrentUserIdLocked()).thenReturn(USER_ID2);

        final boolean result = mServiceConnection.resetMagnification(displayId, true);
        assertThat(result, is(false));
    }

    @Test
    public void setMagnificationConfig_cantControlMagnification_returnFalse() {
        final int displayId = 1;
        final float scale = 1.8f;
        final float centerX = 50.5f;
        final float centerY = 100.5f;
        MagnificationConfig config = new MagnificationConfig.Builder()
                .setScale(scale)
                .setCenterX(centerX)
                .setCenterY(centerY).build();
        when(mMockMagnificationProcessor.setMagnificationConfig(displayId, config, true,
                SERVICE_ID)).thenReturn(true);
        when(mMockSecurityPolicy.canControlMagnification(mServiceConnection)).thenReturn(false);

        final boolean result = mServiceConnection.setMagnificationConfig(displayId, config, true);
        assertFalse(result);
    }

    @Test
    public void setMagnificationConfig_serviceNotBelongCurrentUser_returnFalse() {
        final int displayId = 1;
        final float scale = 1.8f;
        final float centerX = 50.5f;
        final float centerY = 100.5f;
        MagnificationConfig config = new MagnificationConfig.Builder()
                .setScale(scale)
                .setCenterX(centerX)
                .setCenterY(centerY).build();
        when(mMockMagnificationProcessor.setMagnificationConfig(displayId, config, true,
                SERVICE_ID)).thenReturn(true);
        when(mMockSystemSupport.getCurrentUserIdLocked()).thenReturn(USER_ID2);

        final boolean result = mServiceConnection.setMagnificationConfig(displayId, config, true);
        assertFalse(result);
    }

    @Test (expected = SecurityException.class)
    public void takeScreenshot_withoutCapability_throwSecurityException() {
        // no canTakeScreenshot, should throw security exception.
        when(mMockSecurityPolicy.canTakeScreenshotLocked(mServiceConnection)).thenReturn(false);
        mServiceConnection.takeScreenshot(Display.DEFAULT_DISPLAY, new RemoteCallback((result) -> {
        }));
    }

    @Test
    public void takeScreenshot_NoA11yAccess_returnErrorCode() throws InterruptedException {
        // no checkAccessibilityAccess, should return error code.
        when(mMockSecurityPolicy.canTakeScreenshotLocked(mServiceConnection)).thenReturn(true);
        when(mMockSecurityPolicy.checkAccessibilityAccess(mServiceConnection)).thenReturn(false);

        mServiceConnection.takeScreenshot(Display.DEFAULT_DISPLAY,
                new RemoteCallback(mMockListener));
        mHandler.sendLastMessage();

        verify(mMockListener).onResult(Mockito.argThat(
                bundle -> ERROR_TAKE_SCREENSHOT_NO_ACCESSIBILITY_ACCESS
                        == bundle.getInt(KEY_ACCESSIBILITY_SCREENSHOT_STATUS)));
    }

    @Test
    public void takeScreenshot_invalidDisplay_returnErrorCode() throws InterruptedException {
        when(mMockSecurityPolicy.canTakeScreenshotLocked(mServiceConnection)).thenReturn(true);
        when(mMockSecurityPolicy.checkAccessibilityAccess(mServiceConnection)).thenReturn(true);

        final DisplayManager displayManager = new DisplayManager(mMockContext);
        when(mMockContext.getSystemService(Context.DISPLAY_SERVICE)).thenReturn(displayManager);

        mServiceConnection.takeScreenshot(Display.DEFAULT_DISPLAY + 1,
                new RemoteCallback(mMockListener));
        mHandler.sendLastMessage();

        verify(mMockListener).onResult(Mockito.argThat(
                bundle -> ERROR_TAKE_SCREENSHOT_INVALID_DISPLAY
                        == bundle.getInt(KEY_ACCESSIBILITY_SCREENSHOT_STATUS)));
    }

    private void updateServiceInfo(AccessibilityServiceInfo serviceInfo, int eventType,
            int feedbackType, int flags, String[] packageNames, int notificationTimeout) {
        serviceInfo.eventTypes = eventType;
        serviceInfo.feedbackType = feedbackType;
        serviceInfo.flags = flags;
        serviceInfo.packageNames = packageNames;
        serviceInfo.notificationTimeout = notificationTimeout;
    }

    private AccessibilityWindowInfo addA11yWindowInfo(List<AccessibilityWindowInfo> infos,
            int windowId, boolean isPip, int displayId) {
        final AccessibilityWindowInfo info = AccessibilityWindowInfo.obtain();
        info.setId(windowId);
        info.setDisplayId(displayId);
        info.setPictureInPicture(isPip);
        infos.add(info);
        return info;
    }

    private RemoteAccessibilityConnection getRemoteA11yConnection(int windowId,
            IAccessibilityInteractionConnection connection,
            String packageName) {
        return mMockA11yWindowManager.new RemoteAccessibilityConnection(
                windowId, connection, packageName, UID, USER_ID);
    }

    private void initTestFunctions() {
        // Init functions for accessibility nodes finding and searching by different filter rules.
        // We group them together for the tests because they have similar implementation.
        mFindA11yNodesFunctions = new Callable[] {
                // findAccessibilityNodeInfosByViewId
                () -> mServiceConnection.findAccessibilityNodeInfosByViewId(WINDOWID,
                        ROOT_NODE_ID, VIEWID_RESOURCE_NAME, INTERACTION_ID,
                        mMockCallback, TID),
                // findAccessibilityNodeInfosByText
                () -> mServiceConnection.findAccessibilityNodeInfosByText(WINDOWID,
                        ROOT_NODE_ID, VIEW_TEXT, INTERACTION_ID, mMockCallback, TID),
                // findAccessibilityNodeInfoByAccessibilityId
                () -> mServiceConnection.findAccessibilityNodeInfoByAccessibilityId(WINDOWID,
                        ROOT_NODE_ID, INTERACTION_ID, mMockCallback, 0, TID, null),
                // findFocus
                () -> mServiceConnection.findFocus(WINDOWID, ROOT_NODE_ID, FOCUS_INPUT,
                        INTERACTION_ID, mMockCallback, TID),
                // focusSearch
                () -> mServiceConnection.focusSearch(WINDOWID, ROOT_NODE_ID, FOCUS_DOWN,
                        INTERACTION_ID, mMockCallback, TID)
        };
        // performAccessibilityAction
        mPerformA11yAction = () ->  mServiceConnection.performAccessibilityAction(WINDOWID,
                ROOT_NODE_ID, ACTION_ACCESSIBILITY_FOCUS, null, INTERACTION_ID,
                mMockCallback, TID);
    }

    private void verifyReplaceActions(IAccessibilityInteractionConnectionCallback replacedCallback)
            throws RemoteException {
        final AccessibilityNodeInfo nodeFromApp = AccessibilityNodeInfo.obtain();
        nodeFromApp.setSourceNodeId(AccessibilityNodeInfo.ROOT_NODE_ID, WINDOWID);

        final AccessibilityNodeInfo nodeFromReplacer = AccessibilityNodeInfo.obtain();
        nodeFromReplacer.setSourceNodeId(AccessibilityNodeInfo.ROOT_NODE_ID,
                AccessibilityWindowInfo.PICTURE_IN_PICTURE_ACTION_REPLACER_WINDOW_ID);
        nodeFromReplacer.addAction(AccessibilityAction.ACTION_CLICK);
        nodeFromReplacer.addAction(AccessibilityAction.ACTION_EXPAND);
        final List<AccessibilityNodeInfo> replacerList = Arrays.asList(nodeFromReplacer);

        replacedCallback.setFindAccessibilityNodeInfoResult(nodeFromApp, INTERACTION_ID);
        replacedCallback.setFindAccessibilityNodeInfosResult(replacerList, INTERACTION_ID + 1);

        final ArgumentCaptor<AccessibilityNodeInfo> captor =
                ArgumentCaptor.forClass(AccessibilityNodeInfo.class);
        verify(mMockCallback).setFindAccessibilityNodeInfoResult(captor.capture(),
                eq(INTERACTION_ID));
        assertThat(captor.getValue().getActionList(),
                hasItems(AccessibilityAction.ACTION_CLICK, AccessibilityAction.ACTION_EXPAND));
    }

    private static class TestAccessibilityServiceConnection
            extends AbstractAccessibilityServiceConnection {
        int mResolvedUserId;

        TestAccessibilityServiceConnection(Context context, ComponentName componentName,
                AccessibilityServiceInfo accessibilityServiceInfo, int id, Handler mainHandler,
                Object lock, AccessibilitySecurityPolicy securityPolicy,
                SystemSupport systemSupport, AccessibilityTrace trace,
                WindowManagerInternal windowManagerInternal,
                SystemActionPerformer systemActionPerfomer,
                AccessibilityWindowManager a11yWindowManager) {
            super(context, componentName, accessibilityServiceInfo, id, mainHandler, lock,
                    securityPolicy, systemSupport, trace, windowManagerInternal,
                    systemActionPerfomer, a11yWindowManager);
            mResolvedUserId = USER_ID;
        }

        @Override
        protected boolean hasRightsToCurrentUserLocked() {
            return mResolvedUserId == mSystemSupport.getCurrentUserIdLocked();
        }

        @Override
        public void disableSelf() throws RemoteException {}

        @Override
        public boolean setSoftKeyboardShowMode(int showMode) throws RemoteException {
            return false;
        }

        @Override
        public int getSoftKeyboardShowMode() throws RemoteException {
            return 0;
        }

        @Override
        public boolean switchToInputMethod(String imeId) {
            return false;
        }

        @Override
        public int setInputMethodEnabled(String imeId, boolean enabled) throws RemoteException {
            return AccessibilityService.SoftKeyboardController.ENABLE_IME_FAIL_UNKNOWN;
        }

        @Override
        public boolean isAccessibilityButtonAvailable() throws RemoteException {
            return false;
        }

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {}

        @Override
        public void onServiceDisconnected(ComponentName name) {}

        @Override
        public void binderDied() {}

        @Override
        public boolean isCapturingFingerprintGestures() {
            return mCaptureFingerprintGestures;
        }

        @Override
        public void onFingerprintGestureDetectionActiveChanged(boolean active) {}

        @Override
        public void onFingerprintGesture(int gesture) {}
    }
}