Merge "[EXO] Create a service connection for proxies"

2022-10-17 20:17:42 +00:00
parent ab14210110 a4f4a831d6
commit 4e5f0b5a29
5 changed files with 700 additions and 2 deletions
--- a/core/api/system-current.txt
+++ b/core/api/system-current.txt
@@ -462,6 +462,14 @@ package android {

 }

+package android.accessibilityservice {
+
+  public class AccessibilityServiceInfo implements android.os.Parcelable {
+    method public void setAccessibilityTool(boolean);
+  }
+
+}
+
 package android.accounts {

  public class AccountManager {
--- a/core/api/test-current.txt
+++ b/core/api/test-current.txt
@@ -89,7 +89,6 @@ package android.accessibilityservice {

  public class AccessibilityServiceInfo implements android.os.Parcelable {
    method @NonNull public android.content.ComponentName getComponentName();
-    method public void setAccessibilityTool(boolean);
  }

 }
--- a/core/java/android/accessibilityservice/AccessibilityServiceInfo.java
+++ b/core/java/android/accessibilityservice/AccessibilityServiceInfo.java
@@ -24,6 +24,7 @@ import android.annotation.IntDef;
 import android.annotation.IntRange;
 import android.annotation.NonNull;
 import android.annotation.Nullable;
+import android.annotation.SystemApi;
 import android.annotation.TestApi;
 import android.compat.annotation.ChangeId;
 import android.compat.annotation.EnabledAfter;
@@ -809,6 +810,13 @@ public class AccessibilityServiceInfo implements Parcelable {
        mComponentName = component;
    }

+    /**
+     * @hide
+     */
+    public void setResolveInfo(@NonNull ResolveInfo resolveInfo) {
+        mResolveInfo = resolveInfo;
+    }
+
    /**
     * @hide
     */
@@ -1128,7 +1136,7 @@ public class AccessibilityServiceInfo implements Parcelable {
     *
     * @hide
     */
-    @TestApi
+    @SystemApi
    public void setAccessibilityTool(boolean isAccessibilityTool) {
        mIsAccessibilityTool = isAccessibilityTool;
    }
--- a/services/accessibility/java/com/android/server/accessibility/ProxyAccessibilityServiceConnection.java
+++ b/services/accessibility/java/com/android/server/accessibility/ProxyAccessibilityServiceConnection.java
@@ -0,0 +1,472 @@
+/*
+ * Copyright (C) 2022 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 android.accessibilityservice.AccessibilityServiceInfo;
+import android.accessibilityservice.AccessibilityTrace;
+import android.accessibilityservice.MagnificationConfig;
+import android.annotation.NonNull;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.ParceledListSlice;
+import android.content.pm.ResolveInfo;
+import android.content.pm.ServiceInfo;
+import android.graphics.Region;
+import android.os.Binder;
+import android.os.Handler;
+import android.os.IBinder;
+import android.os.RemoteCallback;
+import android.view.KeyEvent;
+import android.view.accessibility.AccessibilityNodeInfo;
+
+import androidx.annotation.Nullable;
+
+import com.android.server.wm.WindowManagerInternal;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * Represents the system connection to an {@link android.view.accessibility.AccessibilityProxy}.
+ *
+ * <p>Most methods are no-ops since this connection does not need to capture input or listen to
+ * hardware-related changes.
+ *
+ * TODO(241429275): Initialize this when a proxy is registered.
+ */
+public class ProxyAccessibilityServiceConnection extends AccessibilityServiceConnection {
+    // Names used to populate ComponentName and ResolveInfo
+    private static final String PROXY_COMPONENT_PACKAGE_NAME = "ProxyPackage";
+    private static final String PROXY_COMPONENT_CLASS_NAME = "ProxyClass";
+
+    private int mDisplayId;
+    private List<AccessibilityServiceInfo> mInstalledAndEnabledServices;
+
+    ProxyAccessibilityServiceConnection(
+            Context context,
+            ComponentName componentName,
+            AccessibilityServiceInfo accessibilityServiceInfo, int id,
+            Handler mainHandler, Object lock,
+            AccessibilitySecurityPolicy securityPolicy,
+            SystemSupport systemSupport, AccessibilityTrace trace,
+            WindowManagerInternal windowManagerInternal,
+            AccessibilityWindowManager awm, int displayId) {
+        super(/* userState= */null, context, componentName, accessibilityServiceInfo, id,
+                mainHandler, lock, securityPolicy, systemSupport, trace, windowManagerInternal,
+                /* systemActionPerformer= */ null, awm, /* activityTaskManagerService= */ null);
+        mDisplayId = displayId;
+    }
+
+    /**
+     * Keeps mAccessibilityServiceInfo in sync with the proxy's list of AccessibilityServiceInfos.
+     *
+     * <p>This also sets the properties that are assumed to be populated by installed packages.
+     *
+     * @param infos the list of enabled and installed services.
+     */
+    @Override
+    public void setInstalledAndEnabledServices(List<AccessibilityServiceInfo> infos) {
+        final long identity = Binder.clearCallingIdentity();
+        try {
+            synchronized (mLock) {
+                mInstalledAndEnabledServices = infos;
+                final AccessibilityServiceInfo proxyInfo = mAccessibilityServiceInfo;
+                // Reset values.
+                proxyInfo.flags = 0;
+                proxyInfo.eventTypes = 0;
+                proxyInfo.notificationTimeout = 0;
+                final Set<String> packageNames = new HashSet<>();
+                boolean hasNullPackagesNames = false;
+                boolean isAccessibilityTool = false;
+                int interactiveUiTimeout = 0;
+                int nonInteractiveUiTimeout = 0;
+
+                // Go through and set properties that are relevant to the proxy. This bypasses
+                // A11yServiceInfo.updateDynamicallyConfigurableProperties since the proxy has
+                // higher security privileges as a SystemAPI and has to set values at runtime.
+                for (AccessibilityServiceInfo info : infos) {
+                    isAccessibilityTool = isAccessibilityTool | info.isAccessibilityTool();
+                    if (info.packageNames == null || info.packageNames.length == 0) {
+                        hasNullPackagesNames = true;
+                    } else if (!hasNullPackagesNames) {
+                        packageNames.addAll(Arrays.asList(info.packageNames));
+                    }
+                    interactiveUiTimeout = Math.max(interactiveUiTimeout,
+                            info.getInteractiveUiTimeoutMillis());
+                    nonInteractiveUiTimeout = Math.max(nonInteractiveUiTimeout,
+                                    info.getNonInteractiveUiTimeoutMillis());
+                    proxyInfo.notificationTimeout = Math.max(proxyInfo.notificationTimeout,
+                            info.notificationTimeout);
+                    proxyInfo.eventTypes |= info.eventTypes;
+                    proxyInfo.feedbackType |= info.feedbackType;
+                    proxyInfo.flags |= info.flags;
+                    // For each info, populate default properties like ResolveInfo.
+                    setDefaultPropertiesIfNullLocked(info);
+                }
+
+                proxyInfo.setAccessibilityTool(isAccessibilityTool);
+                proxyInfo.setInteractiveUiTimeoutMillis(interactiveUiTimeout);
+                proxyInfo.setNonInteractiveUiTimeoutMillis(nonInteractiveUiTimeout);
+
+                // If any one service info doesn't set package names, i.e. if it's interested in all
+                // apps, the proxy shouldn't filter by package name even if some infos specify this.
+                if (hasNullPackagesNames) {
+                    proxyInfo.packageNames = null;
+                } else {
+                    proxyInfo.packageNames = packageNames.toArray(new String[0]);
+                }
+
+                // Update connection with mAccessibilityServiceInfo values.
+                setDynamicallyConfigurableProperties(proxyInfo);
+                // Notify manager service.
+                mSystemSupport.onClientChangeLocked(true);
+            }
+        } finally {
+            Binder.restoreCallingIdentity(identity);
+        }
+    }
+
+    private void setDefaultPropertiesIfNullLocked(AccessibilityServiceInfo info) {
+        final String componentClassDisplayName = PROXY_COMPONENT_CLASS_NAME + mDisplayId;
+        // Populate the properties that can't be null, since this may cause crashes in apps that
+        // assume these are populated by an installed package.
+        if (info.getResolveInfo() == null) {
+            final ResolveInfo resolveInfo = new ResolveInfo();
+            final ServiceInfo serviceInfo = new ServiceInfo();
+            final ApplicationInfo applicationInfo = new ApplicationInfo();
+
+            serviceInfo.packageName = PROXY_COMPONENT_PACKAGE_NAME;
+            serviceInfo.name = componentClassDisplayName;
+
+            applicationInfo.processName = PROXY_COMPONENT_PACKAGE_NAME;
+            applicationInfo.className = componentClassDisplayName;
+
+            resolveInfo.serviceInfo = serviceInfo;
+            serviceInfo.applicationInfo = applicationInfo;
+            info.setResolveInfo(resolveInfo);
+        }
+
+        if (info.getComponentName() == null) {
+            info.setComponentName(new ComponentName(PROXY_COMPONENT_PACKAGE_NAME,
+                            componentClassDisplayName));
+        }
+    }
+
+    @Override
+    public List<AccessibilityServiceInfo> getInstalledAndEnabledServices() {
+        synchronized (mLock) {
+            return mInstalledAndEnabledServices;
+        }
+    }
+
+    @Override
+    public void binderDied() {
+    }
+
+    @Override
+    protected boolean supportsFlagForNotImportantViews(AccessibilityServiceInfo info) {
+        // Don't need to check for earlier APIs.
+        return true;
+    }
+
+    @Override
+    protected boolean hasRightsToCurrentUserLocked() {
+        // TODO(250929565): Proxy access is not currently determined by user. Adjust in refactoring.
+        return true;
+    }
+
+    /** @throws UnsupportedOperationException since a proxy does not need key events */
+    @Override
+    public boolean onKeyEvent(KeyEvent keyEvent, int sequenceNumber)
+            throws UnsupportedOperationException  {
+        throw new UnsupportedOperationException("onKeyEvent is not supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy does not need fingerprint hardware */
+    @Override
+    public boolean isCapturingFingerprintGestures() throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("isCapturingFingerprintGestures is not supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy does not need fingerprint hardware */
+    @Override
+    public void onFingerprintGestureDetectionActiveChanged(boolean active)
+            throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("onFingerprintGestureDetectionActiveChanged is not"
+                + " supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy does not need fingerprint hardware */
+    @Override
+    public void onFingerprintGesture(int gesture) throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("onFingerprintGesture is not supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy does not need fingerprint hardware */
+    @Override
+    public boolean isFingerprintGestureDetectionAvailable() throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("isFingerprintGestureDetectionAvailable is not"
+                + " supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy is not a Service */
+    @Override
+    public void onServiceConnected(ComponentName name, IBinder service)
+            throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("onServiceConnected is not supported");
+
+    }
+
+    /** @throws UnsupportedOperationException since a proxy is not a Service */
+    @Override
+    public void onServiceDisconnected(ComponentName name)
+            throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("onServiceDisconnected is not supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy should use
+     * setInstalledAndEnabledServices*/
+    @Override
+    public void setServiceInfo(AccessibilityServiceInfo info)
+            throws UnsupportedOperationException  {
+        // TODO(241429275): Ensure getServiceInfo is called appropriately for a proxy or is a no-op.
+        throw new UnsupportedOperationException("setServiceInfo is not supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy should use A11yManager#unregister */
+    @Override
+    public void disableSelf() throws UnsupportedOperationException {
+        // A proxy uses A11yManager#unregister to turn itself off.
+        throw new UnsupportedOperationException("disableSelf is not supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy does not have global system access */
+    @Override
+    public boolean performGlobalAction(int action) throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("performGlobalAction is not supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy does not need key events */
+    @Override
+    public void setOnKeyEventResult(boolean handled, int sequence)
+            throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("setOnKeyEventResult is not supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy does not have global system access */
+    @Override
+    public @NonNull List<AccessibilityNodeInfo.AccessibilityAction> getSystemActions()
+            throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("getSystemActions is not supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy does not need magnification */
+    @Nullable
+    @Override
+    public MagnificationConfig getMagnificationConfig(int displayId)
+            throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("getMagnificationConfig is not supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy does not need magnification */
+    @Override
+    public float getMagnificationScale(int displayId) throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("getMagnificationScale is not supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy does not need magnification */
+    @Override
+    public float getMagnificationCenterX(int displayId) throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("getMagnificationCenterX is not supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy does not need magnification */
+    @Override
+    public float getMagnificationCenterY(int displayId) throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("getMagnificationCenterY is not supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy does not need magnification */
+    @Override
+    public Region getMagnificationRegion(int displayId) throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("getMagnificationRegion is not supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy does not need magnification */
+    @Override
+    public Region getCurrentMagnificationRegion(int displayId)
+            throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("getCurrentMagnificationRegion is not supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy does not need magnification */
+    @Override
+    public boolean resetMagnification(int displayId, boolean animate)
+            throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("resetMagnification is not supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy does not need magnification */
+    @Override
+    public boolean resetCurrentMagnification(int displayId, boolean animate)
+            throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("resetCurrentMagnification is not supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy does not need magnification */
+    @Override
+    public boolean setMagnificationConfig(int displayId,
+            @androidx.annotation.NonNull MagnificationConfig config, boolean animate)
+            throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("setMagnificationConfig is not supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy does not need magnification */
+    @Override
+    public void setMagnificationCallbackEnabled(int displayId, boolean enabled)
+            throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("setMagnificationCallbackEnabled is not supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy does not need magnification */
+    @Override
+    public boolean isMagnificationCallbackEnabled(int displayId) {
+        throw new UnsupportedOperationException("isMagnificationCallbackEnabled is not supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy does not need IME access*/
+    @Override
+    public boolean setSoftKeyboardShowMode(int showMode) throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("setSoftKeyboardShowMode is not supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy does not need IME access */
+    @Override
+    public int getSoftKeyboardShowMode() throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("getSoftKeyboardShowMode is not supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy does not need IME access */
+    @Override
+    public void setSoftKeyboardCallbackEnabled(boolean enabled)
+            throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("setSoftKeyboardCallbackEnabled is not supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy does not need IME access */
+    @Override
+    public boolean switchToInputMethod(String imeId) throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("switchToInputMethod is not supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy does not need IME access */
+    @Override
+    public int setInputMethodEnabled(String imeId, boolean enabled)
+            throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("setInputMethodEnabled is not supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy does not need access to the shortcut */
+    @Override
+    public boolean isAccessibilityButtonAvailable() throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("isAccessibilityButtonAvailable is not supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy does not need gestures/input access */
+    @Override
+    public void sendGesture(int sequence, ParceledListSlice gestureSteps)
+            throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("sendGesture is not supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy does not need gestures/input access */
+    @Override
+    public void dispatchGesture(int sequence, ParceledListSlice gestureSteps, int displayId)
+            throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("dispatchGesture is not supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy does not need access to screenshots */
+    @Override
+    public void takeScreenshot(int displayId, RemoteCallback callback)
+            throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("takeScreenshot is not supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy does not need gestures/input access */
+    @Override
+    public void setGestureDetectionPassthroughRegion(int displayId, Region region)
+            throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("setGestureDetectionPassthroughRegion is not"
+                + " supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy does not need gestures/input access */
+    @Override
+    public void setTouchExplorationPassthroughRegion(int displayId, Region region)
+            throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("setTouchExplorationPassthroughRegion is not"
+                + " supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy does not need gestures/input access */
+    @Override
+    public void setServiceDetectsGesturesEnabled(int displayId, boolean mode)
+            throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("setServiceDetectsGesturesEnabled is not"
+                + " supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy does not need touch input access */
+    @Override
+    public void requestTouchExploration(int displayId) throws UnsupportedOperationException  {
+        throw new UnsupportedOperationException("requestTouchExploration is not supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy does not need touch input access */
+    @Override
+    public void requestDragging(int displayId, int pointerId) throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("requestDragging is not supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy does not need touch input access */
+    @Override
+    public void requestDelegating(int displayId) throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("requestDelegating is not supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy does not need touch input access */
+    @Override
+    public void onDoubleTap(int displayId) throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("onDoubleTap is not supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy does not need touch input access */
+    @Override
+    public void onDoubleTapAndHold(int displayId) throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("onDoubleTapAndHold is not supported");
+    }
+
+    /** @throws UnsupportedOperationException since a proxy does not need touch input access */
+    @Override
+    public void setAnimationScale(float scale) throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("setAnimationScale is not supported");
+    }
+}
--- a/services/tests/servicestests/src/com/android/server/accessibility/ProxyAccessibilityServiceConnectionTest.java
+++ b/services/tests/servicestests/src/com/android/server/accessibility/ProxyAccessibilityServiceConnectionTest.java
@@ -0,0 +1,211 @@
+/*
+ * Copyright (C) 2022 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.AccessibilityServiceInfo.FEEDBACK_AUDIBLE;
+import static android.accessibilityservice.AccessibilityServiceInfo.FEEDBACK_GENERIC;
+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_TOUCH_EXPLORATION_MODE;
+
+import static androidx.test.platform.app.InstrumentationRegistry.getInstrumentation;
+
+import android.accessibilityservice.AccessibilityServiceInfo;
+import android.accessibilityservice.AccessibilityTrace;
+import android.content.ComponentName;
+import android.content.Context;
+import android.os.Handler;
+import android.view.accessibility.AccessibilityEvent;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.junit.Assert.assertThrows;
+import static org.mockito.Mockito.verify;
+
+import com.android.server.wm.WindowManagerInternal;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ProxyAccessibilityServiceConnectionTest {
+    private static final int DISPLAY_ID = 1000;
+    private static final int CONNECTION_ID = 1000;
+    private static final ComponentName COMPONENT_NAME = new ComponentName(
+            "com.android.server.accessibility", ".ProxyAccessibilityServiceConnectionTest");
+    public static final int NON_INTERACTIVE_UI_TIMEOUT_100MS = 100;
+    public static final int NON_INTERACTIVE_UI_TIMEOUT_200MS = 200;
+    public static final int INTERACTIVE_UI_TIMEOUT_100MS = 100;
+    public static final int INTERACTIVE_UI_TIMEOUT_200MS = 200;
+    public static final int NOTIFICATION_TIMEOUT_100MS = 100;
+    public static final int NOTIFICATION_TIMEOUT_200MS = 200;
+    public static final String PACKAGE_1 = "package 1";
+    public static final String PACKAGE_2 = "package 2";
+    public static final String PACKAGE_3 = "package 3";
+
+    @Mock
+    Context mMockContext;
+    @Mock
+    Object mMockLock;
+    @Mock
+    AccessibilitySecurityPolicy mMockSecurityPolicy;
+    @Mock
+    AccessibilityWindowManager mMockA11yWindowManager;
+    @Mock AbstractAccessibilityServiceConnection.SystemSupport mMockSystemSupport;
+    @Mock
+    AccessibilityTrace mMockA11yTrace;
+    @Mock
+    WindowManagerInternal mMockWindowManagerInternal;
+    ProxyAccessibilityServiceConnection mProxyConnection;
+    AccessibilityServiceInfo mAccessibilityServiceInfo;
+
+    @Before
+    public void setup() {
+        MockitoAnnotations.initMocks(this);
+        mAccessibilityServiceInfo = new AccessibilityServiceInfo();
+        mProxyConnection = new ProxyAccessibilityServiceConnection(mMockContext, COMPONENT_NAME,
+                mAccessibilityServiceInfo, CONNECTION_ID , new Handler(
+                        getInstrumentation().getContext().getMainLooper()),
+                mMockLock, mMockSecurityPolicy, mMockSystemSupport, mMockA11yTrace,
+                mMockWindowManagerInternal, mMockA11yWindowManager, DISPLAY_ID);
+    }
+
+    @Test
+    public void testSetInstalledAndEnabledServices_clientChanged() {
+        final List<AccessibilityServiceInfo> infos = new ArrayList<>();
+        final AccessibilityServiceInfo info1 = new AccessibilityServiceInfo();
+        infos.add(info1);
+
+        mProxyConnection.setInstalledAndEnabledServices(infos);
+
+        verify(mMockSystemSupport).onClientChangeLocked(true);
+    }
+
+    @Test
+    public void testSetInstalledAndEnabledServices_returnList() {
+        final List<AccessibilityServiceInfo> infos = new ArrayList<>();
+        final AccessibilityServiceInfo info1 = new AccessibilityServiceInfo();
+        final AccessibilityServiceInfo info2 = new AccessibilityServiceInfo();
+        infos.add(info1);
+        infos.add(info2);
+
+        mProxyConnection.setInstalledAndEnabledServices(infos);
+        final List<AccessibilityServiceInfo> infoList =
+                mProxyConnection.getInstalledAndEnabledServices();
+
+        assertThat(infoList.size()).isEqualTo(2);
+        assertThat(infoList.get(0)).isEqualTo(info1);
+        assertThat(infoList.get(1)).isEqualTo(info2);
+    }
+
+    @Test
+    public void testSetInstalledAndEnabledServices_defaultNamesPopulated() {
+        final List<AccessibilityServiceInfo> infos = new ArrayList<>();
+        final AccessibilityServiceInfo info1 = new AccessibilityServiceInfo();
+        infos.add(info1);
+
+        mProxyConnection.setInstalledAndEnabledServices(infos);
+        final List<AccessibilityServiceInfo> infoList =
+                mProxyConnection.getInstalledAndEnabledServices();
+
+        assertThat(infoList.get(0).getComponentName()).isNotNull();
+        assertThat(infoList.get(0).getResolveInfo()).isNotNull();
+    }
+
+    @Test
+    public void testSetInstalledAndEnabledServices_connectionInfoIsUnion() {
+        final List<AccessibilityServiceInfo> infos = new ArrayList<>();
+        final AccessibilityServiceInfo info1 = new AccessibilityServiceInfo();
+        info1.setAccessibilityTool(true);
+        info1.packageNames = new String[]{PACKAGE_1, PACKAGE_2};
+        info1.setInteractiveUiTimeoutMillis(INTERACTIVE_UI_TIMEOUT_200MS);
+        info1.setNonInteractiveUiTimeoutMillis(NON_INTERACTIVE_UI_TIMEOUT_100MS);
+        info1.notificationTimeout = NOTIFICATION_TIMEOUT_100MS;
+        info1.eventTypes = AccessibilityEvent.TYPE_VIEW_CLICKED;
+        info1.feedbackType = FEEDBACK_AUDIBLE;
+        info1.flags = FLAG_INCLUDE_NOT_IMPORTANT_VIEWS;
+        infos.add(info1);
+
+        final AccessibilityServiceInfo info2 = new AccessibilityServiceInfo();
+        info2.packageNames = new String[]{PACKAGE_2, PACKAGE_3};
+        info2.setInteractiveUiTimeoutMillis(INTERACTIVE_UI_TIMEOUT_100MS);
+        info2.setNonInteractiveUiTimeoutMillis(NON_INTERACTIVE_UI_TIMEOUT_200MS);
+        info2.notificationTimeout = NOTIFICATION_TIMEOUT_200MS;
+        info2.eventTypes = AccessibilityEvent.TYPES_ALL_MASK;
+        info2.feedbackType = FEEDBACK_GENERIC;
+        info2.flags = FLAG_REQUEST_TOUCH_EXPLORATION_MODE | FLAG_REPORT_VIEW_IDS;
+        infos.add(info2);
+
+        mProxyConnection.setInstalledAndEnabledServices(infos);
+
+        assertThat(mAccessibilityServiceInfo.isAccessibilityTool()).isTrue();
+        // Package 1, 2, 3
+        assertThat(mAccessibilityServiceInfo.packageNames).asList().containsExactly(
+                PACKAGE_1, PACKAGE_2, PACKAGE_3);
+        assertThat(mAccessibilityServiceInfo.getInteractiveUiTimeoutMillis()).isEqualTo(
+                INTERACTIVE_UI_TIMEOUT_200MS);
+        assertThat(mAccessibilityServiceInfo.getNonInteractiveUiTimeoutMillis()).isEqualTo(
+                NON_INTERACTIVE_UI_TIMEOUT_200MS);
+        assertThat(mAccessibilityServiceInfo.notificationTimeout).isEqualTo(
+                NOTIFICATION_TIMEOUT_200MS);
+        assertThat(mAccessibilityServiceInfo.eventTypes).isEqualTo(
+                AccessibilityEvent.TYPES_ALL_MASK);
+        assertThat(mAccessibilityServiceInfo.feedbackType).isEqualTo(FEEDBACK_AUDIBLE
+                | FEEDBACK_GENERIC);
+        assertThat(mAccessibilityServiceInfo.flags).isEqualTo(FLAG_INCLUDE_NOT_IMPORTANT_VIEWS
+                | FLAG_REQUEST_TOUCH_EXPLORATION_MODE | FLAG_REPORT_VIEW_IDS);
+    }
+
+    @Test
+    public void testSetInstalledAndEnabledServices_emptyPackageNames_packageNamesIsNull() {
+        final List<AccessibilityServiceInfo> infos = new ArrayList<>();
+        final AccessibilityServiceInfo info1 = new AccessibilityServiceInfo();
+        info1.packageNames = new String[]{PACKAGE_1, PACKAGE_2};
+        infos.add(info1);
+        final AccessibilityServiceInfo info2 = new AccessibilityServiceInfo();
+        infos.add(info2);
+
+        mProxyConnection.setInstalledAndEnabledServices(infos);
+
+        final String[] packageNames = mAccessibilityServiceInfo.packageNames;
+        assertThat(packageNames).isNull();
+    }
+
+    @Test
+    public void testSetServiceInfo_setIllegalOperationExceptionThrown_() {
+        UnsupportedOperationException thrown =
+                assertThrows(
+                        UnsupportedOperationException.class,
+                        () -> mProxyConnection.setServiceInfo(new AccessibilityServiceInfo()));
+
+        assertThat(thrown).hasMessageThat().contains("setServiceInfo is not supported");
+    }
+
+    @Test
+    public void testDisableSelf_setIllegalOperationExceptionThrown_() {
+        UnsupportedOperationException thrown =
+                assertThrows(
+                        UnsupportedOperationException.class,
+                        () -> mProxyConnection.disableSelf());
+
+        assertThat(thrown).hasMessageThat().contains("disableSelf is not supported");
+    }
+}