Java Code Examples for android.view.accessibility.AccessibilityEvent#TYPE_VIEW_TEXT_SELECTION_CHANGED

public void handleAccessibilityEvent(AccessibilityEvent event, AccessibilityNodeInfo rootNode){
    int eventType = event.getEventType();
    if (eventType == AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED
            || eventType == AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED
            || eventType == AccessibilityEvent.TYPE_WINDOWS_CHANGED
            || eventType == AccessibilityEvent.TYPE_VIEW_TEXT_SELECTION_CHANGED)
    {
        this.output(new AccEvent(event, rootNode));
    }

}
 

@Override
public void sendAccessibilityEventUnchecked(AccessibilityEvent event) {
    if (mDisableTextAccessibilityEvents) {
        if (event.getEventType() == AccessibilityEvent.TYPE_VIEW_TEXT_SELECTION_CHANGED
                || event.getEventType() == AccessibilityEvent.TYPE_VIEW_TEXT_CHANGED) {
            return;
        }
    }
    super.sendAccessibilityEventUnchecked(event);
}
 

@Override
public void sendAccessibilityEventUnchecked(AccessibilityEvent event) {
    if (mDisableTextAccessibilityEvents) {
        if (event.getEventType() == AccessibilityEvent.TYPE_VIEW_TEXT_SELECTION_CHANGED
                || event.getEventType() == AccessibilityEvent.TYPE_VIEW_TEXT_CHANGED) {
            return;
        }
    }
    super.sendAccessibilityEventUnchecked(event);
}
 

private boolean shouldSkipCursorMovementEvent(AccessibilityEvent event) {
  AccessibilityEvent lastKeptTextSelection = textEventHistory.getLastKeptTextSelection();
  if (lastKeptTextSelection == null) {
    return false;
  }

  // If event is at least X later than previous event, then keep it.
  if (event.getEventTime() - lastKeptTextSelection.getEventTime()
      > CURSOR_MOVEMENT_EVENTS_DELAY) {
    textEventHistory.setLastKeptTextSelection(null);
    return false;
  }

  // If event has the same type as previous, it is from a different action, so keep it.
  if (event.getEventType() == lastKeptTextSelection.getEventType()) {
    return false;
  }

  // If text-selection-change is followed by text-move-with-granularity, skip movement.
  if (lastKeptTextSelection.getEventType() == AccessibilityEvent.TYPE_VIEW_TEXT_SELECTION_CHANGED
      && event.getEventType()
          == AccessibilityEvent.TYPE_VIEW_TEXT_TRAVERSED_AT_MOVEMENT_GRANULARITY) {
    return true;
  }

  return false;
}
 

/** Extract a text event interpretation data from event. May return null. */
public @Nullable TextEventInterpretation interpret(AccessibilityEvent event) {
  // Interpret more specific event type.
  @Compositor.Event int eventType = event.getEventType();
  TextEventInterpretation interpretation;
  boolean isTextEvent = false;
  switch (eventType) {
    case AccessibilityEvent.TYPE_VIEW_TEXT_CHANGED:
      interpretation = interpretTextChange(event);
      isTextEvent = true;
      break;

    case AccessibilityEvent.TYPE_VIEW_TEXT_SELECTION_CHANGED:
    case AccessibilityEvent.TYPE_VIEW_TEXT_TRAVERSED_AT_MOVEMENT_GRANULARITY:
      interpretation = interpretSelectionChange(event);
      isTextEvent = true;
      break;

    default:
      return null;
  }

  // Display interpretation, seal interpretation.
  interpretation.setReadOnly();
  if (isTextEvent) {
    LogUtils.i(TAG, "interpretation: %s", interpretation);
  }
  return interpretation;
}
 

public static int[] getAllEventTypes() {
  return new int[] {
    AccessibilityEvent.TYPE_ANNOUNCEMENT,
    AccessibilityEvent.TYPE_ASSIST_READING_CONTEXT,
    AccessibilityEvent.TYPE_GESTURE_DETECTION_END,
    AccessibilityEvent.TYPE_GESTURE_DETECTION_START,
    AccessibilityEvent.TYPE_NOTIFICATION_STATE_CHANGED,
    AccessibilityEvent.TYPE_TOUCH_EXPLORATION_GESTURE_END,
    AccessibilityEvent.TYPE_TOUCH_EXPLORATION_GESTURE_START,
    AccessibilityEvent.TYPE_TOUCH_INTERACTION_END,
    AccessibilityEvent.TYPE_TOUCH_INTERACTION_START,
    AccessibilityEvent.TYPE_VIEW_ACCESSIBILITY_FOCUSED,
    AccessibilityEvent.TYPE_VIEW_ACCESSIBILITY_FOCUS_CLEARED,
    AccessibilityEvent.TYPE_VIEW_CLICKED,
    AccessibilityEvent.TYPE_VIEW_CONTEXT_CLICKED,
    AccessibilityEvent.TYPE_VIEW_FOCUSED,
    AccessibilityEvent.TYPE_VIEW_HOVER_ENTER,
    AccessibilityEvent.TYPE_VIEW_HOVER_EXIT,
    AccessibilityEvent.TYPE_VIEW_LONG_CLICKED,
    AccessibilityEvent.TYPE_VIEW_SCROLLED,
    AccessibilityEvent.TYPE_VIEW_SELECTED,
    AccessibilityEvent.TYPE_VIEW_TEXT_CHANGED,
    AccessibilityEvent.TYPE_VIEW_TEXT_SELECTION_CHANGED,
    AccessibilityEvent.TYPE_VIEW_TEXT_TRAVERSED_AT_MOVEMENT_GRANULARITY,
    AccessibilityEvent.TYPE_WINDOWS_CHANGED,
    AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED,
    AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED
  };
}
 

@Override
public void onAccessibilityEvent(AccessibilityEvent event, EventId eventId) {
  if (event.getEventType() == AccessibilityEvent.TYPE_VIEW_TEXT_SELECTION_CHANGED) {
    processTextSelectionChange(event);
  } else if (event.getEventType() == AccessibilityEvent.TYPE_VIEW_FOCUSED) {
    processViewInputFocused(event);
  }
}
 

@Override
public void sendAccessibilityEventUnchecked(AccessibilityEvent event) {
    if (mIgnoreTextChangeFromAutocomplete) {
        if (event.getEventType() == AccessibilityEvent.TYPE_VIEW_TEXT_SELECTION_CHANGED
                || event.getEventType() == AccessibilityEvent.TYPE_VIEW_TEXT_CHANGED) {
            return;
        }
    }
    super.sendAccessibilityEventUnchecked(event);
}
 

@Override
public void onInitializeAccessibilityEvent(AccessibilityEvent event) {
    super.onInitializeAccessibilityEvent(event);

    if (event.getEventType() == AccessibilityEvent.TYPE_VIEW_TEXT_SELECTION_CHANGED) {
        CharSequence text = getTextForAccessibility();
        event.setFromIndex(Selection.getSelectionStart(text));
        event.setToIndex(Selection.getSelectionEnd(text));
        event.setItemCount(text.length());
    }
}
 

/**
 * 打印 AccessibilityEvent 信息日志
 * @param event {@link AccessibilityEvent}
 * @param tag   日志 TAG
 */
public static void printAccessibilityEvent(final AccessibilityEvent event, final String tag) {
    if (event == null || !LogPrintUtils.isPrintLog()) return;

    StringBuilder builder = new StringBuilder();
    builder.append("=========================");
    builder.append(NEW_LINE_STR);

    int eventType = event.getEventType(); // 事件类型
    builder.append("packageName: " + event.getPackageName() + ""); // 响应事件的应用包名
    builder.append(NEW_LINE_STR);

    builder.append("source: " + event.getSource() + ""); // 事件源信息
    builder.append(NEW_LINE_STR);

    builder.append("source class: " + event.getClassName() + ""); // 事件源的类名, 如 android.widget.TextView
    builder.append(NEW_LINE_STR);

    builder.append("event type(int): " + eventType + "");
    builder.append(NEW_LINE_STR);

    switch (eventType) {
        case AccessibilityEvent.TYPE_NOTIFICATION_STATE_CHANGED:// 通知栏事件
            builder.append("event type: TYPE_NOTIFICATION_STATE_CHANGED");
            break;
        case AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED: // 窗体状态改变
            builder.append("event type: TYPE_WINDOW_STATE_CHANGED");
            break;
        case AccessibilityEvent.TYPE_VIEW_ACCESSIBILITY_FOCUSED: // View 获取到焦点
            builder.append("event type: TYPE_VIEW_ACCESSIBILITY_FOCUSED");
            break;
        case AccessibilityEvent.TYPE_GESTURE_DETECTION_START:
            builder.append("event type: TYPE_VIEW_ACCESSIBILITY_FOCUSED");
            break;
        case AccessibilityEvent.TYPE_GESTURE_DETECTION_END:
            builder.append("event type: TYPE_GESTURE_DETECTION_END");
            break;
        case AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED:
            builder.append("event type: TYPE_WINDOW_CONTENT_CHANGED");
            break;
        case AccessibilityEvent.TYPE_VIEW_CLICKED:
            builder.append("event type: TYPE_VIEW_CLICKED");
            break;
        case AccessibilityEvent.TYPE_VIEW_TEXT_CHANGED:
            builder.append("event type: TYPE_VIEW_TEXT_CHANGED");
            break;
        case AccessibilityEvent.TYPE_VIEW_SCROLLED:
            builder.append("event type: TYPE_VIEW_SCROLLED");
            break;
        case AccessibilityEvent.TYPE_VIEW_TEXT_SELECTION_CHANGED:
            builder.append("event type: TYPE_VIEW_TEXT_SELECTION_CHANGED");
            break;
    }
    builder.append(NEW_LINE_STR);

    for (CharSequence txt : event.getText()) {
        // 输出当前事件包含的文本信息
        builder.append("text: " + txt);
        builder.append(NEW_LINE_STR);
    }
    builder.append("=========================");

    // 打印日志
    LogPrintUtils.dTag(tag, builder.toString());
}
 

/**
     * Set the content this service should be receiving
     */
    private void setDynamicContent() {
        if (DEBUG) {
            MyLog.i(CLS_NAME, "setDynamicContent: interceptGoogle: " + initInterceptGoogle);
            MyLog.i(CLS_NAME, "setDynamicContent: announceNotifications: " + initAnnounceNotifications);
        }

        if (!initInterceptGoogle && !initAnnounceNotifications) {
            if (DEBUG) {
                MyLog.i(CLS_NAME, "setDynamicContent: none required: finishing");
            }

//            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
//                this.disableSelf();
//            }
//
//            this.stopSelf();

        } else {
            if (DEBUG) {
                MyLog.i(CLS_NAME, "setDynamicContent: updating content");
            }

            final AccessibilityServiceInfo serviceInfo = new AccessibilityServiceInfo();

            serviceInfo.feedbackType = AccessibilityServiceInfo.FEEDBACK_SPOKEN;
            serviceInfo.flags = AccessibilityServiceInfo.FLAG_INCLUDE_NOT_IMPORTANT_VIEWS;
            serviceInfo.notificationTimeout = UPDATE_TIMEOUT;

            if (initInterceptGoogle && initAnnounceNotifications) {
                serviceInfo.eventTypes = AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED
                        | AccessibilityEvent.TYPE_VIEW_TEXT_SELECTION_CHANGED
                        | AccessibilityEvent.TYPE_NOTIFICATION_STATE_CHANGED;
            } else if (initInterceptGoogle) {
                serviceInfo.packageNames = new String[]{Installed.PACKAGE_NAME_GOOGLE_NOW};
                serviceInfo.eventTypes = AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED
                        | AccessibilityEvent.TYPE_VIEW_TEXT_SELECTION_CHANGED;
            } else {
                serviceInfo.eventTypes = AccessibilityEvent.TYPE_NOTIFICATION_STATE_CHANGED;
            }

            this.setServiceInfo(serviceInfo);
        }
    }
 

private boolean shouldDropTextSelectionEvent(AccessibilityEvent event) {
  // Keep all events other than text-selection.
  final int eventType = event.getEventType();
  if (eventType != AccessibilityEvent.TYPE_VIEW_TEXT_SELECTION_CHANGED) {
    return false;
  }

  // Drop selected events until we've matched the number of changed
  // events. This prevents TalkBack from speaking automatic cursor
  // movement events that result from typing.
  if (textEventHistory.getTextChangesAwaitingSelection() > 0) {
    final boolean hasDelayElapsed =
        ((event.getEventTime() - textEventHistory.getLastTextChangeTime())
            >= TEXT_SELECTION_DELAY);
    final boolean hasPackageChanged =
        !TextUtils.equals(
            event.getPackageName(), textEventHistory.getLastTextChangePackageName());

    // If the state is still consistent, update the count and drop the event.
    if (!hasDelayElapsed && !hasPackageChanged) {
      textEventHistory.incrementTextChangesAwaitingSelection(-1);
      textEventHistory.setLastFromIndex(event.getFromIndex());
      textEventHistory.setLastToIndex(event.getToIndex());
      textEventHistory.setLastNode(event.getSource());
      return true;
    }

    // The state became inconsistent, so reset the counter.
    textEventHistory.setTextChangesAwaitingSelection(0);
  }

  // Drop selection events from views that don't have input focus.
  final AccessibilityRecordCompat record = AccessibilityEventCompat.asRecord(event);
  final AccessibilityNodeInfoCompat source = record.getSource();
  boolean isFocused = source != null && source.isFocused();
  AccessibilityNodeInfoUtils.recycleNodes(source);
  if (!isFocused) {
    LogUtils.v(TAG, "Dropped text-selection event from non-focused field");
    return true;
  }

  return false;
}
 

public static String typeToString(int eventType) {
  switch (eventType) {
    case AccessibilityEvent.TYPE_ANNOUNCEMENT:
      return "TYPE_ANNOUNCEMENT";
    case AccessibilityEvent.TYPE_ASSIST_READING_CONTEXT:
      return "TYPE_ASSIST_READING_CONTEXT";
    case AccessibilityEvent.TYPE_GESTURE_DETECTION_END:
      return "TYPE_GESTURE_DETECTION_END";
    case AccessibilityEvent.TYPE_GESTURE_DETECTION_START:
      return "TYPE_GESTURE_DETECTION_START";
    case AccessibilityEvent.TYPE_NOTIFICATION_STATE_CHANGED:
      return "TYPE_NOTIFICATION_STATE_CHANGED";
    case AccessibilityEvent.TYPE_TOUCH_EXPLORATION_GESTURE_END:
      return "TYPE_TOUCH_EXPLORATION_GESTURE_END";
    case AccessibilityEvent.TYPE_TOUCH_EXPLORATION_GESTURE_START:
      return "TYPE_TOUCH_EXPLORATION_GESTURE_START";
    case AccessibilityEvent.TYPE_TOUCH_INTERACTION_END:
      return "TYPE_TOUCH_INTERACTION_END";
    case AccessibilityEvent.TYPE_TOUCH_INTERACTION_START:
      return "TYPE_TOUCH_INTERACTION_START";
    case AccessibilityEvent.TYPE_VIEW_ACCESSIBILITY_FOCUSED:
      return "TYPE_VIEW_ACCESSIBILITY_FOCUSED";
    case AccessibilityEvent.TYPE_VIEW_ACCESSIBILITY_FOCUS_CLEARED:
      return "TYPE_VIEW_ACCESSIBILITY_FOCUS_CLEARED";
    case AccessibilityEvent.TYPE_VIEW_CLICKED:
      return "TYPE_VIEW_CLICKED";
    case AccessibilityEvent.TYPE_VIEW_CONTEXT_CLICKED:
      return "TYPE_VIEW_CONTEXT_CLICKED";
    case AccessibilityEvent.TYPE_VIEW_FOCUSED:
      return "TYPE_VIEW_FOCUSED";
    case AccessibilityEvent.TYPE_VIEW_HOVER_ENTER:
      return "TYPE_VIEW_HOVER_ENTER";
    case AccessibilityEvent.TYPE_VIEW_HOVER_EXIT:
      return "TYPE_VIEW_HOVER_EXIT";
    case AccessibilityEvent.TYPE_VIEW_LONG_CLICKED:
      return "TYPE_VIEW_LONG_CLICKED";
    case AccessibilityEvent.TYPE_VIEW_SCROLLED:
      return "TYPE_VIEW_SCROLLED";
    case AccessibilityEvent.TYPE_VIEW_SELECTED:
      return "TYPE_VIEW_SELECTED";
    case AccessibilityEvent.TYPE_VIEW_TEXT_CHANGED:
      return "TYPE_VIEW_TEXT_CHANGED";
    case AccessibilityEvent.TYPE_VIEW_TEXT_SELECTION_CHANGED:
      return "TYPE_VIEW_TEXT_SELECTION_CHANGED";
    case AccessibilityEvent.TYPE_VIEW_TEXT_TRAVERSED_AT_MOVEMENT_GRANULARITY:
      return "TYPE_VIEW_TEXT_TRAVERSED_AT_MOVEMENT_GRANULARITY";
    case AccessibilityEvent.TYPE_WINDOWS_CHANGED:
      return "TYPE_WINDOWS_CHANGED";
    case AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED:
      return "TYPE_WINDOW_CONTENT_CHANGED";
    case AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED:
      return "TYPE_WINDOW_STATE_CHANGED";
    default:
      return "(unhandled)";
  }
}