/*
* Copyright (C) 2016 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.setupwizardlib.util;
import android.graphics.Rect;
import android.os.Build;
import android.os.Bundle;
import android.support.v4.view.AccessibilityDelegateCompat;
import android.support.v4.view.accessibility.AccessibilityNodeInfoCompat;
import android.support.v4.view.accessibility.AccessibilityNodeProviderCompat;
import android.support.v4.widget.ExploreByTouchHelper;
import android.text.Layout;
import android.text.Spanned;
import android.text.style.ClickableSpan;
import android.util.Log;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.view.accessibility.AccessibilityEvent;
import android.widget.TextView;
import java.util.List;
/**
* An accessibility delegate that allows {@link android.text.style.ClickableSpan} to be focused and
* clicked by accessibility services.
*
* Note: From Android O on, there is native support for ClickableSpan
* accessibility, so this class is not needed (and indeed has no effect.)
*
*
* Sample usage:
*
* LinkAccessibilityHelper mAccessibilityHelper;
*
* private void init() {
* mAccessibilityHelper = new LinkAccessibilityHelper(myTextView);
* ViewCompat.setAccessibilityDelegate(myTextView, mLinkHelper);
* }
*
* {@literal @}Override
* protected boolean dispatchHoverEvent({@literal @}NonNull MotionEvent event) {
* if (mAccessibilityHelper != null && mAccessibilityHelper.dispatchHoverEvent(event)) {
* return true;
* }
* return super.dispatchHoverEvent(event);
* }
*
*
* @see com.android.setupwizardlib.view.RichTextView
* @see android.support.v4.widget.ExploreByTouchHelper
*/
public class LinkAccessibilityHelper extends AccessibilityDelegateCompat {
private static final String TAG = "LinkAccessibilityHelper";
private final TextView mView;
private final Rect mTempRect = new Rect();
private final ExploreByTouchHelper mExploreByTouchHelper;
public LinkAccessibilityHelper(TextView view) {
if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.N_MR1) {
// Pre-O, we essentially extend ExploreByTouchHelper to expose a virtual view hierarchy
mExploreByTouchHelper = new ExploreByTouchHelper(view) {
@Override
protected int getVirtualViewAt(float x, float y) {
return LinkAccessibilityHelper.this.getVirtualViewAt(x, y);
}
@Override
protected void getVisibleVirtualViews(List virtualViewIds) {
LinkAccessibilityHelper.this.getVisibleVirtualViews(virtualViewIds);
}
@Override
protected void onPopulateEventForVirtualView(int virtualViewId,
AccessibilityEvent event) {
LinkAccessibilityHelper
.this.onPopulateEventForVirtualView(virtualViewId, event);
}
@Override
protected void onPopulateNodeForVirtualView(int virtualViewId,
AccessibilityNodeInfoCompat infoCompat) {
LinkAccessibilityHelper
.this.onPopulateNodeForVirtualView(virtualViewId, infoCompat);
}
@Override
protected boolean onPerformActionForVirtualView(int virtualViewId, int action,
Bundle arguments) {
return LinkAccessibilityHelper.this
.onPerformActionForVirtualView(virtualViewId, action, arguments);
}
};
} else {
mExploreByTouchHelper = null;
}
mView = view;
}
@Override
public void sendAccessibilityEvent(View host, int eventType) {
if (mExploreByTouchHelper != null) {
mExploreByTouchHelper.sendAccessibilityEvent(host, eventType);
} else {
super.sendAccessibilityEvent(host, eventType);
}
}
@Override
public void sendAccessibilityEventUnchecked(View host, AccessibilityEvent event) {
if (mExploreByTouchHelper != null) {
mExploreByTouchHelper.sendAccessibilityEventUnchecked(host, event);
} else {
super.sendAccessibilityEventUnchecked(host, event);
}
}
@Override
public boolean dispatchPopulateAccessibilityEvent(View host, AccessibilityEvent event) {
return (mExploreByTouchHelper != null)
? mExploreByTouchHelper.dispatchPopulateAccessibilityEvent(host, event)
: super.dispatchPopulateAccessibilityEvent(host, event);
}
@Override
public void onPopulateAccessibilityEvent(View host, AccessibilityEvent event) {
if (mExploreByTouchHelper != null) {
mExploreByTouchHelper.onPopulateAccessibilityEvent(host, event);
} else {
super.onPopulateAccessibilityEvent(host, event);
}
}
@Override
public void onInitializeAccessibilityEvent(View host, AccessibilityEvent event) {
if (mExploreByTouchHelper != null) {
mExploreByTouchHelper.onInitializeAccessibilityEvent(host, event);
} else {
super.onInitializeAccessibilityEvent(host, event);
}
}
@Override
public void onInitializeAccessibilityNodeInfo(View host, AccessibilityNodeInfoCompat info) {
if (mExploreByTouchHelper != null) {
mExploreByTouchHelper.onInitializeAccessibilityNodeInfo(host, info);
} else {
super.onInitializeAccessibilityNodeInfo(host, info);
}
}
@Override
public boolean onRequestSendAccessibilityEvent(ViewGroup host, View child,
AccessibilityEvent event) {
return (mExploreByTouchHelper != null)
? mExploreByTouchHelper.onRequestSendAccessibilityEvent(host, child, event)
: super.onRequestSendAccessibilityEvent(host, child, event);
}
@Override
public AccessibilityNodeProviderCompat getAccessibilityNodeProvider(View host) {
return (mExploreByTouchHelper != null)
? mExploreByTouchHelper.getAccessibilityNodeProvider(host)
: super.getAccessibilityNodeProvider(host);
}
@Override
public boolean performAccessibilityAction(View host, int action, Bundle args) {
return (mExploreByTouchHelper != null)
? mExploreByTouchHelper.performAccessibilityAction(host, action, args)
: super.performAccessibilityAction(host, action, args);
}
/**
* Delegated to {@link ExploreByTouchHelper}
*/
public final boolean dispatchHoverEvent(MotionEvent event) {
return (mExploreByTouchHelper != null) ? mExploreByTouchHelper.dispatchHoverEvent(event)
: false;
}
protected int getVirtualViewAt(float x, float y) {
final CharSequence text = mView.getText();
if (text instanceof Spanned) {
final Spanned spannedText = (Spanned) text;
final int offset = getOffsetForPosition(mView, x, y);
ClickableSpan[] linkSpans = spannedText.getSpans(offset, offset, ClickableSpan.class);
if (linkSpans.length == 1) {
ClickableSpan linkSpan = linkSpans[0];
return spannedText.getSpanStart(linkSpan);
}
}
return ExploreByTouchHelper.INVALID_ID;
}
protected void getVisibleVirtualViews(List virtualViewIds) {
final CharSequence text = mView.getText();
if (text instanceof Spanned) {
final Spanned spannedText = (Spanned) text;
ClickableSpan[] linkSpans = spannedText.getSpans(0, spannedText.length(),
ClickableSpan.class);
for (ClickableSpan span : linkSpans) {
virtualViewIds.add(spannedText.getSpanStart(span));
}
}
}
protected void onPopulateEventForVirtualView(int virtualViewId, AccessibilityEvent event) {
final ClickableSpan span = getSpanForOffset(virtualViewId);
if (span != null) {
event.setContentDescription(getTextForSpan(span));
} else {
Log.e(TAG, "LinkSpan is null for offset: " + virtualViewId);
event.setContentDescription(mView.getText());
}
}
protected void onPopulateNodeForVirtualView(int virtualViewId,
AccessibilityNodeInfoCompat info) {
final ClickableSpan span = getSpanForOffset(virtualViewId);
if (span != null) {
info.setContentDescription(getTextForSpan(span));
} else {
Log.e(TAG, "LinkSpan is null for offset: " + virtualViewId);
info.setContentDescription(mView.getText());
}
info.setFocusable(true);
info.setClickable(true);
getBoundsForSpan(span, mTempRect);
if (mTempRect.isEmpty()) {
Log.e(TAG, "LinkSpan bounds is empty for: " + virtualViewId);
mTempRect.set(0, 0, 1, 1);
}
info.setBoundsInParent(mTempRect);
info.addAction(AccessibilityNodeInfoCompat.ACTION_CLICK);
}
protected boolean onPerformActionForVirtualView(int virtualViewId, int action,
Bundle arguments) {
if (action == AccessibilityNodeInfoCompat.ACTION_CLICK) {
ClickableSpan span = getSpanForOffset(virtualViewId);
if (span != null) {
span.onClick(mView);
return true;
} else {
Log.e(TAG, "LinkSpan is null for offset: " + virtualViewId);
}
}
return false;
}
private ClickableSpan getSpanForOffset(int offset) {
CharSequence text = mView.getText();
if (text instanceof Spanned) {
Spanned spannedText = (Spanned) text;
ClickableSpan[] spans = spannedText.getSpans(offset, offset, ClickableSpan.class);
if (spans.length == 1) {
return spans[0];
}
}
return null;
}
private CharSequence getTextForSpan(ClickableSpan span) {
CharSequence text = mView.getText();
if (text instanceof Spanned) {
Spanned spannedText = (Spanned) text;
return spannedText.subSequence(spannedText.getSpanStart(span),
spannedText.getSpanEnd(span));
}
return text;
}
// Find the bounds of a span. If it spans multiple lines, it will only return the bounds for the
// section on the first line.
private Rect getBoundsForSpan(ClickableSpan span, Rect outRect) {
CharSequence text = mView.getText();
outRect.setEmpty();
if (text instanceof Spanned) {
final Layout layout = mView.getLayout();
if (layout != null) {
Spanned spannedText = (Spanned) text;
final int spanStart = spannedText.getSpanStart(span);
final int spanEnd = spannedText.getSpanEnd(span);
final float xStart = layout.getPrimaryHorizontal(spanStart);
final float xEnd = layout.getPrimaryHorizontal(spanEnd);
final int lineStart = layout.getLineForOffset(spanStart);
final int lineEnd = layout.getLineForOffset(spanEnd);
layout.getLineBounds(lineStart, outRect);
if (lineEnd == lineStart) {
// If the span is on a single line, adjust both the left and right bounds
// so outrect is exactly bounding the span.
outRect.left = (int) Math.min(xStart, xEnd);
outRect.right = (int) Math.max(xStart, xEnd);
} else {
// If the span wraps across multiple lines, only use the first line (as returned
// by layout.getLineBounds above), and adjust the "start" of outrect to where
// the span starts, leaving the "end" of outrect at the end of the line.
// ("start" being left for LTR, and right for RTL)
if (layout.getParagraphDirection(lineStart) == Layout.DIR_RIGHT_TO_LEFT) {
outRect.right = (int) xStart;
} else {
outRect.left = (int) xStart;
}
}
// Offset for padding
outRect.offset(mView.getTotalPaddingLeft(), mView.getTotalPaddingTop());
}
}
return outRect;
}
// Compat implementation of TextView#getOffsetForPosition().
private static int getOffsetForPosition(TextView view, float x, float y) {
if (view.getLayout() == null) return -1;
final int line = getLineAtCoordinate(view, y);
return getOffsetAtCoordinate(view, line, x);
}
private static float convertToLocalHorizontalCoordinate(TextView view, float x) {
x -= view.getTotalPaddingLeft();
// Clamp the position to inside of the view.
x = Math.max(0.0f, x);
x = Math.min(view.getWidth() - view.getTotalPaddingRight() - 1, x);
x += view.getScrollX();
return x;
}
private static int getLineAtCoordinate(TextView view, float y) {
y -= view.getTotalPaddingTop();
// Clamp the position to inside of the view.
y = Math.max(0.0f, y);
y = Math.min(view.getHeight() - view.getTotalPaddingBottom() - 1, y);
y += view.getScrollY();
return view.getLayout().getLineForVertical((int) y);
}
private static int getOffsetAtCoordinate(TextView view, int line, float x) {
x = convertToLocalHorizontalCoordinate(view, x);
return view.getLayout().getOffsetForHorizontal(line, x);
}
}