Java tutorial
/* * Copyright (C) 2015 Google Inc. * * 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.googlecode.eyesfree.testing; import android.Manifest.permission; import android.accessibilityservice.AccessibilityService; import android.accessibilityservice.AccessibilityServiceInfo; import android.annotation.TargetApi; import android.app.Activity; import android.content.ContentResolver; import android.content.Context; import android.content.pm.PackageManager; import android.content.pm.ServiceInfo; import android.os.Build; import android.os.Bundle; import android.os.Parcelable; import android.os.SystemClock; import android.provider.Settings; import android.support.v4.view.accessibility.AccessibilityNodeInfoCompat; import android.test.ActivityInstrumentationTestCase2; import android.util.Log; import android.view.View; import android.view.accessibility.AccessibilityEvent; import android.view.accessibility.AccessibilityManager; import android.view.accessibility.AccessibilityManager.AccessibilityStateChangeListener; import android.view.accessibility.AccessibilityNodeInfo; import com.android.utils.LogUtils; import com.android.utils.TestActivity; import java.util.ArrayList; import java.util.List; public abstract class BaseAccessibilityInstrumentationTestCase extends ActivityInstrumentationTestCase2<TestActivity> { private static final String TOUCH_EXPLORATION_GRANTED_ACCESSIBILITY_SERVICES = "touch_exploration_granted_accessibility_services"; // Used to obtain nodes from views. private static final int NODE_INFO_EVENT_TYPE = AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED; // Used to synchronize with the TalkBack event queue. private static final int SYNC_EVENT_TYPE = AccessibilityEvent.TYPE_NOTIFICATION_STATE_CHANGED; private static final Bundle SYNC_PARCELABLE = new Bundle(); private static final String SYNC_KEY = "key"; private static final double SYNC_VALUE = (Math.random() + 1.0); static { SYNC_PARCELABLE.putDouble(SYNC_KEY, SYNC_VALUE); } /** Maximum time to wait while attempting to obtain a service instance. */ private static final long OBTAIN_SERVICE_TIMEOUT = 2000; /** Delay between retries while attempting to obtain a service instance. */ private static final long OBTAIN_SERVICE_RETRY = 100; /** Maximum time to wait while changing the accessibility state. */ private static final long STATE_CHANGE_TIMEOUT = 3000; /** Maximum time to wait for a specific event. */ private static final long OBTAIN_EVENT_TIMEOUT = 2000; /** Maximum time to wait for the service to stop receiving events. */ private static final long NO_EVENTS_TIMEOUT = 2000; /** Minimum time to wait for the service to stop receiving events. */ private static final long NO_EVENTS_DURATION = 500; /** Fake view ID used to temporarily identify views. */ private static final int FAKE_VIEW_ID = Integer.MAX_VALUE; /** List of recorded events. */ private final ArrayList<AccessibilityEvent> mEventCache = new ArrayList<>(); private final Object mAccessibilityStateLock = new Object(); private final Object mAccessibilityEventLock = new Object(); private AccessibilityManager mManager; private boolean mAccessibilityState; private boolean mRecordingEvents; private long mLastEventTime; protected Context mInsCtx; protected Context mAppCtx; public BaseAccessibilityInstrumentationTestCase() { super(TestActivity.class); } @Override protected void setUp() throws Exception { super.setUp(); LogUtils.setLogLevel(Log.VERBOSE); mInsCtx = getInstrumentation().getContext(); mAppCtx = getInstrumentation().getTargetContext(); mManager = (AccessibilityManager) mAppCtx.getSystemService(Context.ACCESSIBILITY_SERVICE); assertEquals( "Has WRITE_SECURE_SETTINGS permission (did you run \"adb shell pm grant " + mInsCtx.getPackageName() + " android.permission.WRITE_SECURE_SETTINGS\"?)", PackageManager.PERMISSION_GRANTED, mInsCtx.getPackageManager() .checkPermission(permission.WRITE_SECURE_SETTINGS, mInsCtx.getPackageName())); AccessibilityService service = getService(); // Ensure the TalkBack and system accessibility states are in sync. if ((service == null) || !mManager.isEnabled()) { disableAllServices(); obtainNullTargetServiceSync(); enableTargetService(); obtainTargetServiceSync(); service = getService(); } assertNotNull("Connected to service", service); connectServiceListener(); } @Override protected void tearDown() throws Exception { super.tearDown(); disconnectServiceListener(); disableAllServices(); } protected abstract AccessibilityService getService(); protected abstract void enableTargetService(); protected abstract void connectServiceListener(); protected abstract void disconnectServiceListener(); /** * Finds an {@link android.view.accessibility.AccessibilityNodeInfo} by View id in the active window. * The search is performed from the root node. * * @param viewId The id of a View. * @return An {@link android.view.accessibility.AccessibilityNodeInfo} if found, null otherwise. */ protected final AccessibilityNodeInfo findAccessibilityNodeInfoByViewIdInActiveWindow(int viewId) { startRecordingEvents(); final View view = getViewForId(viewId); assertNotNull("Obtain view from activity", view); final AccessibilityEvent event = AccessibilityEvent.obtain(); event.setEnabled(false); event.setEventType(NODE_INFO_EVENT_TYPE); event.setParcelableData(SYNC_PARCELABLE); event.setSource(view); // Sending the event through the manager sets the event time and // may clear the source node. Only certain event types can be // dispatched (see the framework's AccessibilityManagerService // canDispatchAccessibilityEvent() method). mManager.sendAccessibilityEvent(event); final AccessibilityEvent syncedEvent = stopRecordingEventsAfter(mNodeInfoEventFilter); assertNotNull("Synchronized event queue", syncedEvent); final AccessibilityNodeInfo sourceNode = syncedEvent.getSource(); assertNotNull("Obtained source node from event", sourceNode); return sourceNode; } protected void assertServiceIsInstalled(String servicePackage, String serviceName) { final List<AccessibilityServiceInfo> services = mManager.getInstalledAccessibilityServiceList(); for (AccessibilityServiceInfo service : services) { final ServiceInfo serviceInfo = service.getResolveInfo().serviceInfo; final String packageName = serviceInfo.applicationInfo.packageName; if (servicePackage.equals(packageName) && serviceName.equals(serviceInfo.name)) { return; } } assertTrue("Service " + servicePackage + "/" + serviceName + " is not installed", false); } /** * Calls {@link android.app.Activity#setContentView} with the specified * layout resource and waits for a layout pass. * <p> * An initial layout pass is required for * {@link android.view.accessibility.AccessibilityNodeInfo#isVisibleToUser} to return the correct * value. * * @param layoutResID Resource ID to be passed to * {@link android.app.Activity#setContentView}. */ protected void setContentView(final int layoutResID) { final Activity activity = getActivity(); try { runTestOnUiThread(new Runnable() { @Override public void run() { activity.setContentView(layoutResID); } }); waitForAccessibilityIdleSync(); waitForEventQueueSync(); } catch (Throwable e) { e.printStackTrace(); } } /** * Disables all accessibility services by clearing all accessibility-related * settings (e.g. enabled services, accessibility enabled, etc.). */ protected void disableAllServices() { final ContentResolver cr = mInsCtx.getContentResolver(); Settings.Secure.putString(cr, Settings.Secure.ENABLED_ACCESSIBILITY_SERVICES, ""); // Granting touch exploration is only supported on JB and above. Settings.Secure.putString(cr, TOUCH_EXPLORATION_GRANTED_ACCESSIBILITY_SERVICES, ""); Settings.Secure.putInt(cr, Settings.Secure.ACCESSIBILITY_ENABLED, 0); Settings.Secure.putInt(cr, Settings.Secure.TOUCH_EXPLORATION_ENABLED, 0); mAccessibilityState = assertAccessibilityStateSync(false); } /** * Enables the specified accessibility service and turns on accessibility. * <p> Setting {@code usesExploreByTouch} grants * the service permission to turn on Explore by Touch. To enable the * feature, you must request it in your service configuration. * * @param packageName The package containing the service to enable. * @param className The class name of the service to enable. * @param usesExploreByTouch Whether the service uses Explore by Touch. */ protected void enableService(String packageName, String className, boolean usesExploreByTouch) { final String fullPackage = packageName + "/" + className; final ContentResolver cr = mInsCtx.getContentResolver(); Settings.Secure.putString(cr, Settings.Secure.ENABLED_ACCESSIBILITY_SERVICES, fullPackage); String enabledService = Settings.Secure.getString(cr, Settings.Secure.ENABLED_ACCESSIBILITY_SERVICES); assertEquals(fullPackage, enabledService); // Granting touch exploration is only supported on JB and above. if (usesExploreByTouch) { Settings.Secure.putString(cr, TOUCH_EXPLORATION_GRANTED_ACCESSIBILITY_SERVICES, fullPackage); } Settings.Secure.putInt(cr, Settings.Secure.ACCESSIBILITY_ENABLED, 1); int accessibilityEnabled = Settings.Secure.getInt(cr, Settings.Secure.ACCESSIBILITY_ENABLED, 0); assertEquals(1, accessibilityEnabled); mAccessibilityState = assertAccessibilityStateSync(true); } private boolean assertAccessibilityStateSync(boolean enabled) { final boolean state; final long startTime = SystemClock.uptimeMillis(); synchronized (mAccessibilityStateLock) { mManager.addAccessibilityStateChangeListener(mStateListener); try { while (true) { if (mManager.isEnabled() == enabled) { break; } final long elapsed = (SystemClock.uptimeMillis() - startTime); final long timeLeft = (STATE_CHANGE_TIMEOUT - elapsed); if (timeLeft <= 0) { break; } mAccessibilityStateLock.wait(timeLeft); } } catch (InterruptedException e) { // Do nothing. } state = mManager.isEnabled(); assertEquals("Toggled accessibility state", enabled, state); mManager.removeAccessibilityStateChangeListener(mStateListener); } LogUtils.log(this, Log.VERBOSE, "Took %d ms to enable accessibility", (SystemClock.uptimeMillis() - startTime)); return state; } protected void waitForEventQueueSync() throws Throwable { startRecordingEvents(); final AccessibilityEvent event = AccessibilityEvent.obtain(); event.setEnabled(false); event.setEventType(SYNC_EVENT_TYPE); event.setParcelableData(SYNC_PARCELABLE); // Sending the event through the manager sets the event time and // may clear the source node. Only certain event types can be // dispatched (see the framework's AccessibilityManagerService // canDispatchAccessibilityEvent() method). mManager.sendAccessibilityEvent(event); final AccessibilityEvent syncedEvent = stopRecordingEventsAfter(mSyncEventFilter); assertNotNull("Synchronized event queue", syncedEvent); } /** * Ensures that {@link #NO_EVENTS_DURATION} milliseconds have passed since * the last accessibility event. */ protected void waitForAccessibilityIdleSync() { boolean hasIdleSync = false; final long startTime = SystemClock.uptimeMillis(); synchronized (mAccessibilityEventLock) { try { // Reset the event time to now so that we catch queued events. mLastEventTime = SystemClock.uptimeMillis(); while (true) { final long eventTimeElapsed = (SystemClock.uptimeMillis() - mLastEventTime); final long eventTimeLeft = (NO_EVENTS_DURATION - eventTimeElapsed); if (eventTimeLeft <= 0) { hasIdleSync = true; break; } final long timeElapsed = (SystemClock.uptimeMillis() - startTime); final long timeLeft = (NO_EVENTS_TIMEOUT - timeElapsed); if (timeLeft <= 0) { break; } final long timeToWait = Math.min(timeLeft, eventTimeLeft); mAccessibilityEventLock.wait(timeToWait); } } catch (InterruptedException e) { // Do nothing. } assertTrue("Accessibility events idle for " + NO_EVENTS_DURATION + " ms", hasIdleSync); } LogUtils.log(this, Log.VERBOSE, "Took %d ms to sync accessibility idle state", (SystemClock.uptimeMillis() - startTime)); } /** * Returns the {@link android.view.View} for the specified id. * * @param viewId The id of the view to obtain. * @return The view, or {@code null}. */ protected View getViewForId(int viewId) { if (viewId <= 0) { return null; } final View view = getActivity().findViewById(viewId); assertNotNull("Obtain view with id " + viewId, view); return view; } /** * Returns the {@link android.support.v4.view.accessibility.AccessibilityNodeInfoCompat} for a specific view, or * {@code null} if the view is invalid or an error occurred while obtaining * the info. * * @param viewId The id of the view whose node to obtain. * @return The view's node info, or {@code null}. */ protected AccessibilityNodeInfoCompat getNodeForId(int viewId) { if (viewId <= 0) { return null; } final AccessibilityNodeInfo node = findAccessibilityNodeInfoByViewIdInActiveWindow(viewId); assertNotNull("Obtain node from view id " + viewId, node); return new AccessibilityNodeInfoCompat(node); } /** * Returns the {@link android.support.v4.view.accessibility.AccessibilityNodeInfoCompat} for a specific view, or * {@code null} if the view is invalid or an error occurred while obtaining * the info. * * @param view The view whose node to obtain. * @return The view's node info, or {@code null}. */ protected AccessibilityNodeInfoCompat getNodeForView(View view) { if (view == null) { return null; } final int realViewId = view.getId(); view.setId(FAKE_VIEW_ID); final AccessibilityNodeInfoCompat node = getNodeForId(FAKE_VIEW_ID); view.setId(realViewId); return node; } protected void startRecordingEvents() { synchronized (mEventCache) { mEventCache.clear(); mRecordingEvents = true; } } protected AccessibilityEvent stopRecordingEventsAfter(EventFilter filter) { final long startTime = SystemClock.uptimeMillis(); synchronized (mEventCache) { try { int currentIndex = 0; while (true) { // Check all events starting from the current index. while (currentIndex < mEventCache.size()) { final AccessibilityEvent event = mEventCache.get(currentIndex); if (filter.accept(event)) { mRecordingEvents = false; return event; } currentIndex++; } final long elapsed = (SystemClock.uptimeMillis() - startTime); final long timeLeft = (OBTAIN_EVENT_TIMEOUT - elapsed); if (timeLeft <= 0) { break; } mEventCache.wait(timeLeft); } mRecordingEvents = false; } catch (InterruptedException e) { // Do nothing. } } return null; } /** * Attempts to obtain a null instance of {@link TestAccessibilityService}. * <p> * May block for up to {@link #OBTAIN_SERVICE_TIMEOUT} seconds, and may * return {@code null} if the service is not running. */ private boolean obtainNullTargetServiceSync() { boolean success = false; final long startTime = SystemClock.uptimeMillis(); try { while (true) { final AccessibilityService service = getService(); if (service == null) { break; } final long timeElapsed = (SystemClock.uptimeMillis() - startTime); final long timeLeft = (OBTAIN_SERVICE_TIMEOUT - timeElapsed); if (timeLeft <= 0) { break; } final long timeToWait = Math.min(OBTAIN_SERVICE_RETRY, timeLeft); Thread.sleep(timeToWait); } } catch (InterruptedException e) { // Do nothing. } LogUtils.log(this, Log.VERBOSE, "Took %d ms to obtain null service", (SystemClock.uptimeMillis() - startTime)); return success; } /** * Attempts to obtain an instance of {@link TestAccessibilityService}. * <p> * May block for up to {@link #OBTAIN_SERVICE_TIMEOUT} seconds, and may * return {@code null} if the service is not running. */ private boolean obtainTargetServiceSync() { boolean success = false; final long startTime = SystemClock.uptimeMillis(); try { while (true) { final AccessibilityService service = getService(); if (service != null) { break; } final long timeElapsed = (SystemClock.uptimeMillis() - startTime); final long timeLeft = (OBTAIN_SERVICE_TIMEOUT - timeElapsed); if (timeLeft <= 0) { break; } final long timeToWait = Math.min(OBTAIN_SERVICE_RETRY, timeLeft); Thread.sleep(timeToWait); } } catch (InterruptedException e) { // Do nothing. } LogUtils.log(this, Log.VERBOSE, "Took %d ms to obtain service", (SystemClock.uptimeMillis() - startTime)); return success; } protected void onEventReceived(AccessibilityEvent event) { synchronized (mAccessibilityEventLock) { mLastEventTime = SystemClock.uptimeMillis(); } synchronized (mEventCache) { if (mRecordingEvents) { mEventCache.add(AccessibilityEvent.obtain(event)); mEventCache.notifyAll(); } } } /** Event filter used to synchronize with the TalkBack event queue. */ private final EventFilter mNodeInfoEventFilter = new EventFilter() { @Override public boolean accept(AccessibilityEvent event) { if (event.getEventType() != NODE_INFO_EVENT_TYPE) { return false; } final Parcelable parcel = event.getParcelableData(); return parcel instanceof Bundle && (((Bundle) parcel).getDouble(SYNC_KEY) == SYNC_VALUE); } }; /** Event filter used to synchronize with the TalkBack event queue. */ private final EventFilter mSyncEventFilter = new EventFilter() { @Override public boolean accept(AccessibilityEvent event) { if (event.getEventType() != SYNC_EVENT_TYPE) { return false; } final Parcelable parcel = event.getParcelableData(); return parcel instanceof Bundle && (((Bundle) parcel).getDouble(SYNC_KEY) == SYNC_VALUE); } }; private final AccessibilityStateChangeListener mStateListener = new AccessibilityStateChangeListener() { @Override public void onAccessibilityStateChanged(boolean enabled) { synchronized (mAccessibilityStateLock) { mAccessibilityState = enabled; mAccessibilityStateLock.notifyAll(); } } }; }