Java tutorial
/* * Copyright (C) 2012 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.talkback.controller; import android.annotation.TargetApi; import android.content.Context; import android.os.Build; import android.os.PowerManager; import android.support.v4.view.accessibility.AccessibilityEventCompat; import android.support.v4.view.accessibility.AccessibilityNodeInfoCompat; import android.util.Log; import android.view.accessibility.AccessibilityEvent; import com.android.talkback.CursorGranularity; import com.android.talkback.InputModeManager; import com.android.talkback.R; import com.android.talkback.SpeechController; import com.google.android.marvin.talkback.TalkBackService; import com.android.talkback.eventprocessor.EventState; import com.android.utils.AccessibilityEventListener; import com.android.utils.AccessibilityEventUtils; import com.android.utils.AccessibilityNodeInfoUtils; import com.android.utils.LogUtils; import com.android.utils.WebInterfaceUtils; import com.android.utils.compat.accessibilityservice.AccessibilityServiceCompatUtils; import com.android.utils.traversal.OrderedTraversalStrategy; import com.android.utils.traversal.TraversalStrategy; public class FullScreenReadControllerApp implements FullScreenReadController, AccessibilityEventListener { /** Tag used for log output and wake lock */ private static final String TAG = "FullScreenReadController"; /** The possible states of the controller. */ private static final int STATE_STOPPED = 0; private static final int STATE_READING_FROM_BEGINNING = 1; private static final int STATE_READING_FROM_NEXT = 2; private static final int STATE_ENTERING_LEGACY_WEB_CONTENT = 3; /** Event types that should interrupt continuous reading, if active. */ private static final int MASK_EVENT_TYPES_INTERRUPT_CONTINUOUS = AccessibilityEvent.TYPE_VIEW_CLICKED | AccessibilityEvent.TYPE_VIEW_LONG_CLICKED | AccessibilityEvent.TYPE_VIEW_SELECTED | AccessibilityEvent.TYPE_VIEW_TEXT_CHANGED | AccessibilityEventCompat.TYPE_ANNOUNCEMENT | AccessibilityEventCompat.TYPE_GESTURE_DETECTION_START | AccessibilityEventCompat.TYPE_TOUCH_EXPLORATION_GESTURE_START | AccessibilityEventCompat.TYPE_TOUCH_INTERACTION_START | AccessibilityEventCompat.TYPE_VIEW_HOVER_ENTER | AccessibilityEventCompat.TYPE_VIEW_TEXT_SELECTION_CHANGED; /** * The current state of the controller. Should only be updated through * {@link FullScreenReadControllerApp#setReadingState(int)} */ private int mCurrentState = STATE_STOPPED; /** The parent service */ private final TalkBackService mService; /** Controller for linearly navigating the view hierarchy tree */ private CursorController mCursorController; /** Feedback controller for audio feedback */ private final FeedbackController mFeedbackController; /** Wake lock for keeping the device unlocked while reading */ private PowerManager.WakeLock mWakeLock; @SuppressWarnings("deprecation") public FullScreenReadControllerApp(FeedbackController feedbackController, CursorController cursorController, TalkBackService service) { if (cursorController == null) throw new IllegalStateException(); if (feedbackController == null) throw new IllegalStateException(); mCursorController = cursorController; mFeedbackController = feedbackController; mService = service; mWakeLock = ((PowerManager) service.getSystemService(Context.POWER_SERVICE)) .newWakeLock(PowerManager.SCREEN_DIM_WAKE_LOCK | PowerManager.ON_AFTER_RELEASE, TAG); } /** * Releases all resources held by this controller and save any persistent * preferences. */ public void shutdown() { interrupt(); } /** * Starts linearly reading from the node with accessibility focus. */ public void startReadingFromNextNode() { if (isActive()) { return; } final AccessibilityNodeInfoCompat currentNode = mCursorController.getCursor(); if (currentNode == null) { return; } setReadingState(STATE_READING_FROM_NEXT); mCursorController.setGranularity(CursorGranularity.DEFAULT, false /* fromUser */); if (!mWakeLock.isHeld()) { mWakeLock.acquire(); } // Avoid reading the elements in web content twice by calling directly // into ChromeVox rather than advancing CursorController first. if (WebInterfaceUtils.hasLegacyWebContent(currentNode)) { moveIntoWebContent(); } else { moveForward(); } currentNode.recycle(); } /** * Starts linearly reading from the top of the view hierarchy. */ public void startReadingFromBeginning() { AccessibilityNodeInfoCompat rootNode = null; AccessibilityNodeInfoCompat currentNode = null; if (isActive()) { return; } try { rootNode = AccessibilityServiceCompatUtils.getRootInActiveWindow(mService); if (rootNode == null) { return; } TraversalStrategy traversal = new OrderedTraversalStrategy(rootNode); try { currentNode = AccessibilityNodeInfoUtils.searchFocus(traversal, rootNode, TraversalStrategy.SEARCH_FOCUS_FORWARD, AccessibilityNodeInfoUtils.FILTER_SHOULD_FOCUS); } finally { traversal.recycle(); } if (currentNode == null) { return; } setReadingState(STATE_READING_FROM_BEGINNING); mCursorController.setGranularity(CursorGranularity.DEFAULT, false /* fromUser */); if (!mWakeLock.isHeld()) { mWakeLock.acquire(); } // This is potentially a refocus, so we should set the refocus flag just in case. EventState.getInstance().addEvent(EventState.EVENT_NODE_REFOCUSED); mCursorController.clearCursor(); mCursorController.setCursor(currentNode); // Will automatically move forward. if (WebInterfaceUtils.hasLegacyWebContent(currentNode)) { moveIntoWebContent(); } } finally { AccessibilityNodeInfoUtils.recycleNodes(rootNode, currentNode); } } /** * Stops speech output and view traversal at the current position. */ public void interrupt() { setReadingState(STATE_STOPPED); if (mWakeLock.isHeld()) { mWakeLock.release(); } } private void moveForward() { if (!mCursorController.next(false /* shouldWrap */, false /* shouldScroll */, false /*useInputFocusAsPivotIfEmpty*/, InputModeManager.INPUT_MODE_UNKNOWN)) { mFeedbackController.playAuditory(R.raw.complete, 1.3f, 1); interrupt(); } if (currentNodeHasWebContent()) { moveIntoWebContent(); } } private void moveIntoWebContent() { final AccessibilityNodeInfoCompat webNode = mCursorController.getCursor(); if (webNode == null) { // Reset state. interrupt(); return; } if (mCurrentState == STATE_READING_FROM_BEGINNING) { // Reset ChromeVox's active indicator to the start to the page. WebInterfaceUtils.performNavigationAtGranularityAction(webNode, WebInterfaceUtils.DIRECTION_BACKWARD, AccessibilityNodeInfoCompat.MOVEMENT_GRANULARITY_PAGE); } WebInterfaceUtils.performNavigationAtGranularityAction(webNode, WebInterfaceUtils.DIRECTION_FORWARD, AccessibilityNodeInfoCompat.MOVEMENT_GRANULARITY_PAGE); setReadingState(STATE_ENTERING_LEGACY_WEB_CONTENT); webNode.recycle(); } private void setReadingState(int newState) { LogUtils.log(TAG, Log.VERBOSE, "Continuous reading switching to mode: %s", newState); mCurrentState = newState; TalkBackService service = TalkBackService.getInstance(); if (service != null) { service.getSpeechController().setShouldInjectAutoReadingCallbacks(isActive(), mNodeSpokenRunnable); } } public boolean isReadingLegacyWebContent() { return mCurrentState == STATE_ENTERING_LEGACY_WEB_CONTENT; } /** * Returns whether full-screen reading is currently active. Equivalent to * calling {@code mCurrentState != STATE_STOPPED}. * * @return Whether full-screen reading is currently active. */ public boolean isActive() { return mCurrentState != STATE_STOPPED; } private boolean currentNodeHasWebContent() { final AccessibilityNodeInfoCompat currentNode = mCursorController.getCursor(); if (currentNode == null) { return false; } final boolean isWebContent = WebInterfaceUtils.hasLegacyWebContent(currentNode); currentNode.recycle(); return isWebContent; } @Override public void onAccessibilityEvent(AccessibilityEvent event) { if (!isActive()) { return; } // Only interrupt full screen reading on events that can't be generated // by automated cursor movement or from delayed user interaction. if (AccessibilityEventUtils.eventMatchesAnyType(event, MASK_EVENT_TYPES_INTERRUPT_CONTINUOUS)) { interrupt(); } } /** Runnable executed when a node has finished being spoken */ private final SpeechController.UtteranceCompleteRunnable mNodeSpokenRunnable = new SpeechController.UtteranceCompleteRunnable() { @Override public void run(int status) { if (isActive() && !isReadingLegacyWebContent() && status != SpeechController.STATUS_INTERRUPTED) { moveForward(); } } }; }