Commit 90b97b56 authored by Alan Viverette's avatar Alan Viverette Committed by Android Git Automerger
Browse files

am 090a46d6: Add a virtual node provider to the date picker.

* commit '090a46d6':
  Add a virtual node provider to the date picker.
parents ccf99c51 090a46d6
......@@ -347,4 +347,59 @@ public class DayPickerView extends ListView implements OnScrollListener, OnDateC
public void onDateChanged() {
goTo(mController.getSelectedDay(), false, true, true);
}
/**
* Attempts to return the date that has accessibility focus.
*
* @return The date that has accessibility focus, or {@code null} if no date
* has focus.
*/
private CalendarDay findAccessibilityFocus() {
final int childCount = getChildCount();
for (int i = 0; i < childCount; i++) {
final View child = getChildAt(i);
if (child instanceof SimpleMonthView) {
final CalendarDay focus = ((SimpleMonthView) child).getAccessibilityFocus();
if (focus != null) {
// Clear focus to avoid ListView bug in Jelly Bean MR1.
((SimpleMonthView) child).clearAccessibilityFocus();
return focus;
}
}
}
return null;
}
/**
* Attempts to restore accessibility focus to a given date. No-op if
* {@code day} is {@code null}.
*
* @param day The date that should receive accessibility focus
* @return {@code true} if focus was restored
*/
private boolean restoreAccessibilityFocus(CalendarDay day) {
if (day == null) {
return false;
}
final int childCount = getChildCount();
for (int i = 0; i < childCount; i++) {
final View child = getChildAt(i);
if (child instanceof SimpleMonthView) {
if (((SimpleMonthView) child).restoreAccessibilityFocus(day)) {
return true;
}
}
}
return false;
}
@Override
protected void layoutChildren() {
final CalendarDay focusedDay = findAccessibilityFocus();
super.layoutChildren();
restoreAccessibilityFocus(focusedDay);
}
}
......@@ -18,28 +18,26 @@ package com.android.datetimepicker.date;
import android.content.Context;
import android.util.Log;
import android.view.GestureDetector;
import android.view.MotionEvent;
import android.view.View;
import android.view.View.OnTouchListener;
import android.view.ViewGroup;
import android.widget.AbsListView.LayoutParams;
import android.widget.BaseAdapter;
import com.android.datetimepicker.date.SimpleMonthView.OnDayClickListener;
import java.util.Calendar;
import java.util.HashMap;
/**
* An adapter for a list of {@link SimpleMonthView} items.
*/
public class SimpleMonthAdapter extends BaseAdapter implements OnTouchListener {
public class SimpleMonthAdapter extends BaseAdapter implements OnDayClickListener {
private static final String TAG = "SimpleMonthAdapter";
private final Context mContext;
private final DatePickerController mController;
private GestureDetector mGestureDetector;
private CalendarDay mSelectedDay;
protected static int WEEK_7_OVERHANG_HEIGHT = 7;
......@@ -121,7 +119,6 @@ public class SimpleMonthAdapter extends BaseAdapter implements OnTouchListener {
* Set up the gesture detector and selected time
*/
protected void init() {
mGestureDetector = new GestureDetector(mContext, new CalendarGestureListener());
mSelectedDay = new CalendarDay(System.currentTimeMillis());
}
......@@ -156,7 +153,7 @@ public class SimpleMonthAdapter extends BaseAdapter implements OnTouchListener {
LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
v.setLayoutParams(params);
v.setClickable(true);
v.setOnTouchListener(this);
v.setOnDayClickListener(this);
}
if (drawingParams == null) {
drawingParams = new HashMap<String, Integer>();
......@@ -190,15 +187,10 @@ public class SimpleMonthAdapter extends BaseAdapter implements OnTouchListener {
}
@Override
public boolean onTouch(View v, MotionEvent event) {
if (mGestureDetector.onTouchEvent(event)) {
CalendarDay day = ((SimpleMonthView) v).getDayFromLocation(event.getX(), event.getY());
if (day != null) {
onDayTapped(day);
}
return true;
public void onDayClick(SimpleMonthView view, CalendarDay day) {
if (day != null) {
onDayTapped(day);
}
return false;
}
/**
......@@ -211,15 +203,4 @@ public class SimpleMonthAdapter extends BaseAdapter implements OnTouchListener {
mController.onDayOfMonthSelected(day.year, day.month, day.day);
setSelectedDay(day);
}
/**
* This is here so we can identify single tap events and set the selected
* day correctly
*/
protected class CalendarGestureListener extends GestureDetector.SimpleOnGestureListener {
@Override
public boolean onSingleTapUp(MotionEvent e) {
return true;
}
}
}
......@@ -22,17 +22,27 @@ import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Paint.Align;
import android.graphics.Paint.Style;
import android.graphics.Rect;
import android.graphics.Typeface;
import android.os.Bundle;
import android.support.v4.view.ViewCompat;
import android.support.v4.view.accessibility.AccessibilityNodeInfoCompat;
import android.text.format.Time;
import android.util.SparseArray;
import android.view.MotionEvent;
import android.view.View;
import android.view.accessibility.AccessibilityEvent;
import android.view.accessibility.AccessibilityNodeInfo;
import com.android.datetimepicker.R;
import com.android.datetimepicker.Utils;
import com.android.datetimepicker.date.SimpleMonthAdapter.CalendarDay;
import com.googlecode.eyesfree.utils.TouchExplorationHelper;
import java.security.InvalidParameterException;
import java.util.Calendar;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
/**
......@@ -152,9 +162,15 @@ public class SimpleMonthView extends View {
private final Calendar mCalendar;
private final Calendar mDayLabelCalendar;
private final MonthViewNodeProvider mNodeProvider;
private int mNumRows = DEFAULT_NUM_ROWS;
// Optional listener for handling day click actions
private OnDayClickListener mOnDayClickListener;
// Whether to prevent setting the accessibility delegate
private boolean mLockAccessibilityDelegate;
protected int mDayTextColor;
protected int mTodayNumberColor;
protected int mMonthTitleColor;
......@@ -185,10 +201,52 @@ public class SimpleMonthView extends View {
mRowHeight = (res.getDimensionPixelOffset(R.dimen.date_picker_view_animator_height)
- MONTH_HEADER_SIZE) / MAX_NUM_ROWS;
// Set up accessibility components.
mNodeProvider = new MonthViewNodeProvider(context, this);
ViewCompat.setAccessibilityDelegate(this, mNodeProvider.getAccessibilityDelegate());
ViewCompat.setImportantForAccessibility(this, ViewCompat.IMPORTANT_FOR_ACCESSIBILITY_YES);
mLockAccessibilityDelegate = true;
// Sets up any standard paints that will be used
initView();
}
@Override
public void setAccessibilityDelegate(AccessibilityDelegate delegate) {
// Workaround for a JB MR1 issue where accessibility delegates on
// top-level ListView items are overwritten.
if (!mLockAccessibilityDelegate) {
super.setAccessibilityDelegate(delegate);
}
}
public void setOnDayClickListener(OnDayClickListener listener) {
mOnDayClickListener = listener;
}
@Override
public boolean onHoverEvent(MotionEvent event) {
// First right-of-refusal goes the touch exploration helper.
if (mNodeProvider.onHover(this, event)) {
return true;
}
return super.onHoverEvent(event);
}
@Override
public boolean onTouchEvent(MotionEvent event) {
switch (event.getAction()) {
case MotionEvent.ACTION_UP:
final CalendarDay day = getDayFromLocation(event.getX(), event.getY());
if (day != null) {
onDayClick(day);
}
break;
}
return true;
}
/**
* Sets up the text and style properties for painting. Override this if you
* want to use a different paint.
......@@ -301,6 +359,9 @@ public class SimpleMonthView extends View {
}
}
mNumRows = calculateNumRows();
// Invalidate cached accessibility information.
mNodeProvider.invalidateParent();
}
public void reuse() {
......@@ -330,6 +391,9 @@ public class SimpleMonthView extends View {
@Override
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
mWidth = w;
// Invalidate cached accessibility information.
mNodeProvider.invalidateParent();
}
private void drawMonthTitle(Canvas canvas) {
......@@ -421,4 +485,190 @@ public class SimpleMonthView extends View {
return new CalendarDay(mYear, mMonth, day);
}
/**
* Called when the user clicks on a day. Handles callbacks to the
* {@link OnDayClickListener} if one is set.
*
* @param day A time object representing the day that was clicked
*/
private void onDayClick(CalendarDay day) {
if (mOnDayClickListener != null) {
mOnDayClickListener.onDayClick(this, day);
}
// This is a no-op if accessibility is turned off.
mNodeProvider.sendEventForItem(day, AccessibilityEvent.TYPE_VIEW_CLICKED);
}
/**
* @return The date that has accessibility focus, or {@code null} if no date
* has focus
*/
public CalendarDay getAccessibilityFocus() {
return mNodeProvider.getFocusedItem();
}
/**
* Clears accessibility focus within the view. No-op if the view does not
* contain accessibility focus.
*/
public void clearAccessibilityFocus() {
mNodeProvider.clearFocusedItem();
}
/**
* Attempts to restore accessibility focus to the specified date.
*
* @param day The date which should receive focus
* @return {@code false} if the date is not valid for this month view, or
* {@code true} if the date received focus
*/
public boolean restoreAccessibilityFocus(CalendarDay day) {
if ((day.year != mYear) || (day.month != mMonth) || (day.day > mNumCells)) {
return false;
}
mNodeProvider.setFocusedItem(day);
return true;
}
/**
* Provides a virtual view hierarchy for interfacing with an accessibility
* service.
*/
private class MonthViewNodeProvider extends TouchExplorationHelper<CalendarDay> {
private final SparseArray<CalendarDay> mCachedItems = new SparseArray<CalendarDay>();
private final Rect mTempRect = new Rect();
public MonthViewNodeProvider(Context context, View parent) {
super(context, parent);
}
@Override
public void invalidateItem(CalendarDay item) {
super.invalidateItem(item);
mCachedItems.delete(getIdForItem(item));
}
@Override
public void invalidateParent() {
super.invalidateParent();
mCachedItems.clear();
}
@Override
protected boolean performActionForItem(CalendarDay item, int action, Bundle arguments) {
switch (action) {
case AccessibilityNodeInfo.ACTION_CLICK:
onDayClick(item);
return true;
}
return false;
}
@Override
protected void populateEventForItem(CalendarDay item, AccessibilityEvent event) {
event.setContentDescription(getItemDescription(item));
}
@Override
protected void populateNodeForItem(CalendarDay item, AccessibilityNodeInfoCompat node) {
getItemBounds(item, mTempRect);
node.setContentDescription(getItemDescription(item));
node.setBoundsInParent(mTempRect);
node.addAction(AccessibilityNodeInfo.ACTION_CLICK);
if (item.day == mSelectedDay) {
node.setSelected(true);
}
}
@Override
protected void getVisibleItems(List<CalendarDay> items) {
// TODO: Optimize, only return items visible within parent bounds.
for (int day = 1; day <= mNumCells; day++) {
items.add(getItemForId(day));
}
}
@Override
protected CalendarDay getItemAt(float x, float y) {
return getDayFromLocation(x, y);
}
@Override
protected int getIdForItem(CalendarDay item) {
return item.day;
}
@Override
protected CalendarDay getItemForId(int id) {
if ((id < 1) || (id > mNumCells)) {
return null;
}
final CalendarDay item;
if (mCachedItems.indexOfKey(id) >= 0) {
item = mCachedItems.get(id);
} else {
item = new CalendarDay(mYear, mMonth, id);
mCachedItems.put(id, item);
}
return item;
}
/**
* Calculates the bounding rectangle of a given time object.
*
* @param item The time object to calculate bounds for
* @param rect The rectangle in which to store the bounds
*/
private void getItemBounds(CalendarDay item, Rect rect) {
final int offsetX = mPadding;
final int offsetY = MONTH_HEADER_SIZE;
final int cellHeight = mRowHeight;
final int cellWidth = ((mWidth - (2 * mPadding)) / mNumDays);
final int index = ((item.day - 1) + findDayOffset());
final int row = (index / mNumDays);
final int column = (index % mNumDays);
final int x = (offsetX + (column * cellWidth));
final int y = (offsetY + (row * cellHeight));
rect.set(x, y, (x + cellWidth), (y + cellHeight));
}
/**
* Generates a description for a given time object. Since this
* description will be spoken, the components are ordered by descending
* specificity as DAY MONTH YEAR.
*
* @param item The time object to generate a description for
* @return A description of the time object
*/
private CharSequence getItemDescription(CalendarDay item) {
final StringBuffer sbuf = new StringBuffer();
sbuf.append(String.format("%d", item.day));
sbuf.append(" ");
sbuf.append(mCalendar.getDisplayName(Calendar.MONTH, Calendar.LONG,
Locale.getDefault()));
sbuf.append(" ");
sbuf.append(String.format("%d", mYear));
if (item.day == mSelectedDay) {
return getContext().getString(R.string.item_is_selected, sbuf);
}
return sbuf;
}
}
/**
* Handles callbacks when the user clicks on a time object.
*/
public interface OnDayClickListener {
public void onDayClick(SimpleMonthView view, CalendarDay day);
}
}
/*
* Copyright (C) 2012 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.utils;
import android.content.Context;
import android.graphics.Rect;
import android.os.Bundle;
import android.support.v4.view.AccessibilityDelegateCompat;
import android.support.v4.view.ViewCompat;
import android.support.v4.view.accessibility.AccessibilityNodeInfoCompat;
import android.support.v4.view.accessibility.AccessibilityNodeProviderCompat;
import android.support.v4.view.accessibility.AccessibilityRecordCompat;
import android.text.TextUtils;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.view.accessibility.AccessibilityEvent;
import android.view.accessibility.AccessibilityManager;
import java.util.LinkedList;
import java.util.List;
public abstract class TouchExplorationHelper<T> extends AccessibilityNodeProviderCompat
implements View.OnHoverListener {
/** Virtual node identifier value for invalid nodes. */
public static final int INVALID_ID = Integer.MIN_VALUE;
private final Rect mTempScreenRect = new Rect();
private final Rect mTempParentRect = new Rect();
private final Rect mTempVisibleRect = new Rect();
private final int[] mTempGlobalRect = new int[2];
private final AccessibilityManager mManager;
private View mParentView;
private int mFocusedItemId = INVALID_ID;
private T mCurrentItem = null;
/**
* Constructs a new touch exploration helper.
*
* @param context The parent context.
*/
public TouchExplorationHelper(Context context, View parentView) {
mManager = (AccessibilityManager) context.getSystemService(Context.ACCESSIBILITY_SERVICE);
mParentView = parentView;
}
/**
* @return The current accessibility focused item, or {@code null} if no
* item is focused.
*/
public T getFocusedItem() {
return getItemForId(mFocusedItemId);
}
/**
* Clears the current accessibility focused item.
*/
public void clearFocusedItem() {
final int itemId = mFocusedItemId;
if (itemId == INVALID_ID) {
return;
}
performAction(itemId, AccessibilityNodeInfoCompat.ACTION_CLEAR_ACCESSIBILITY_FOCUS, null);
}
/**
* Requests accessibility focus be placed on the specified item.
*
* @param item The item to place focus on.
*/
public void setFocusedItem(T item) {
final int itemId = getIdForItem(item);
if (itemId == INVALID_ID) {
return;
}
performAction(itemId, AccessibilityNodeInfoCompat.ACTION_ACCESSIBILITY_FOCUS, null);
}
/**
* Invalidates cached information about the parent view.
* <p>
* You <b>must</b> call this method after adding or removing items from the
* parent view.
* </p>
*/
public void invalidateParent() {
mParentView.sendAccessibilityEvent(AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED);
}
/**
* Invalidates cached information for a particular item.
* <p>
* You <b>must</b> call this method when any of the properties set in
* {@link #populateNodeForItem(Object, AccessibilityNodeInfoCompat)} have
* changed.
* </p>
*
* @param item
*/
public void invalidateItem(T item) {
sendEventForItem(item, AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED);
}
/**
* Populates an event of the specified type with information about an item
* and attempts to send it up through the view hierarchy.
*
* @param item The item for which to send an event.
* @param eventType The type of event to send.
* @return {@code true} if the event was sent successfully.
*/
public boolean sendEventForItem(T item, int eventType) {
if (!mManager.isEnabled()) {
return false;
}
final AccessibilityEvent event = getEventForItem(item, eventType);
final ViewGroup group = (ViewGroup) mParentView.getParent();
return group.requestSendAccessibilityEvent(mParentView, event);
}
@Override
public AccessibilityNodeInfoCompat createAccessibilityNodeInfo(int virtualViewId) {
if (virtualViewId == View.NO_ID) {
return getNodeForParent();
}
final T item = getItemForId(virtualViewId);
if (item == null) {
return null;
}
final AccessibilityNodeInfoCompat node = AccessibilityNodeInfoCompat.obtain();
populateNodeForItemInternal(item, node);
return node;
}
@Override
public boolean performAction(int virtualViewId, int action, Bundle arguments) {
if (virtualViewId == View.NO_ID) {
return ViewCompat.performAccessibilityAction(mParentView, action, arguments);
}
final T item = getItemForId(virtualViewId);
if (item == null) {
return false;
}
boolean handled = false;
switch (action) {
case AccessibilityNodeInfoCompat.ACTION_ACCESSIBILITY_FOCUS:
if (mFocusedItemId != virtualViewId) {
mFocusedItemId = virtualViewId;
sendEventForItem(item, AccessibilityEvent.TYPE_VIEW_ACCESSIBILITY_FOCUSED);
handled = true;
}
break;
case AccessibilityNodeInfoCompat.ACTION_CLEAR_ACCESSIBILITY_FOCUS:
if (mFocusedItemId == virtualViewId) {
mFocusedItemId = INVALID_ID;
sendEventForItem(item, AccessibilityEvent.TYPE_VIEW_ACCESSIBILITY_FOCUS_CLEARED);
handled = true;
}
break;
}
handled |= performActionForItem(item, action, arguments);
return handled;
}
@Override
public boolean onHover(View view, MotionEvent event) {
if (!mManager.isTouchExplorationEnabled()) {
return false;
}
switch (event.getAction()) {
case MotionEvent.ACTION_HOVER_ENTER:
case MotionEvent.ACTION_HOVER_MOVE:
final T item = getItemAt(event.getX(), event.getY());
setCurrentItem(item);
return true;
case MotionEvent.ACTION_HOVER_EXIT:
setCurrentItem(null);
return true;
}
return false;
}
private void setCurrentItem(T item) {
if (mCurrentItem == item) {
return;
}
if (mCurrentItem != null) {
sendEventForItem(mCurrentItem, AccessibilityEvent.TYPE_VIEW_HOVER_EXIT);
}
mCurrentItem = item;
if (mCurrentItem != null) {
sendEventForItem(mCurrentItem, AccessibilityEvent.TYPE_VIEW_HOVER_ENTER);
}
}
private AccessibilityEvent getEventForItem(T item, int eventType) {
final AccessibilityEvent event = AccessibilityEvent.obtain(eventType);
final AccessibilityRecordCompat record = new AccessibilityRecordCompat(event);
final int virtualDescendantId = getIdForItem(item);
// Ensure the client has good defaults.
event.setEnabled(true);
// Allow the client to populate the event.
populateEventForItem(item, event);
if (event.getText().isEmpty() && TextUtils.isEmpty(event.getContentDescription())) {
throw new RuntimeException(
"You must add text or a content description in populateEventForItem()");
}
// Don't allow the client to override these properties.
event.setClassName(item.getClass().getName());
event.setPackageName(mParentView.getContext().getPackageName());
record.setSource(mParentView, virtualDescendantId);
return event;
}
private AccessibilityNodeInfoCompat getNodeForParent() {
final AccessibilityNodeInfoCompat info = AccessibilityNodeInfoCompat.obtain(mParentView);
ViewCompat.onInitializeAccessibilityNodeInfo(mParentView, info);
final LinkedList<T> items = new LinkedList<T>();
getVisibleItems(items);
for (T item : items) {
final int virtualDescendantId = getIdForItem(item);
info.addChild(mParentView, virtualDescendantId);
}
return info;
}
private AccessibilityNodeInfoCompat populateNodeForItemInternal(
T item, AccessibilityNodeInfoCompat node) {
final int virtualDescendantId = getIdForItem(item);
// Ensure the client has good defaults.
node.setEnabled(true);
// Allow the client to populate the node.
populateNodeForItem(item, node);
if (TextUtils.isEmpty(node.getText()) && TextUtils.isEmpty(node.getContentDescription())) {
throw new RuntimeException(
"You must add text or a content description in populateNodeForItem()");
}
// Don't allow the client to override these properties.
node.setPackageName(mParentView.getContext().getPackageName());
node.setClassName(item.getClass().getName());
node.setParent(mParentView);
node.setSource(mParentView, virtualDescendantId);
if (mFocusedItemId == virtualDescendantId) {
node.addAction(AccessibilityNodeInfoCompat.ACTION_CLEAR_ACCESSIBILITY_FOCUS);
} else {
node.addAction(AccessibilityNodeInfoCompat.ACTION_ACCESSIBILITY_FOCUS);
}
node.getBoundsInParent(mTempParentRect);
if (mTempParentRect.isEmpty()) {
throw new RuntimeException("You must set parent bounds in populateNodeForItem()");
}
// Set the visibility based on the parent bound.
if (intersectVisibleToUser(mTempParentRect)) {
node.setVisibleToUser(true);
node.setBoundsInParent(mTempParentRect);
}
// Calculate screen-relative bound.
mParentView.getLocationOnScreen(mTempGlobalRect);
final int offsetX = mTempGlobalRect[0];
final int offsetY = mTempGlobalRect[1];
mTempScreenRect.set(mTempParentRect);
mTempScreenRect.offset(offsetX, offsetY);
node.setBoundsInScreen(mTempScreenRect);
return node;
}
/**
* Computes whether the specified {@link Rect} intersects with the visible
* portion of its parent {@link View}. Modifies {@code localRect} to
* contain only the visible portion.
*
* @param localRect A rectangle in local (parent) coordinates.
* @return Whether the specified {@link Rect} is visible on the screen.
*/
private boolean intersectVisibleToUser(Rect localRect) {
// Missing or empty bounds mean this view is not visible.
if ((localRect == null) || localRect.isEmpty()) {
return false;
}
// Attached to invisible window means this view is not visible.
if (mParentView.getWindowVisibility() != View.VISIBLE) {
return false;
}
// An invisible predecessor or one with alpha zero means
// that this view is not visible to the user.
Object current = this;
while (current instanceof View) {
final View view = (View) current;
// We have attach info so this view is attached and there is no
// need to check whether we reach to ViewRootImpl on the way up.
if ((view.getAlpha() <= 0) || (view.getVisibility() != View.VISIBLE)) {
return false;
}
current = view.getParent();
}
// If no portion of the parent is visible, this view is not visible.
if (!mParentView.getLocalVisibleRect(mTempVisibleRect)) {
return false;
}
// Check if the view intersects the visible portion of the parent.
return localRect.intersect(mTempVisibleRect);
}
public AccessibilityDelegateCompat getAccessibilityDelegate() {
return mDelegate;
}
private final AccessibilityDelegateCompat mDelegate = new AccessibilityDelegateCompat() {
@Override
public void onInitializeAccessibilityEvent(View view, AccessibilityEvent event) {
super.onInitializeAccessibilityEvent(view, event);
event.setClassName(view.getClass().getName());
}
@Override
public void onInitializeAccessibilityNodeInfo(View view, AccessibilityNodeInfoCompat info) {
super.onInitializeAccessibilityNodeInfo(view, info);
info.setClassName(view.getClass().getName());
}
@Override
public AccessibilityNodeProviderCompat getAccessibilityNodeProvider(View host) {
return TouchExplorationHelper.this;
}
};
/**
* Performs an accessibility action on the specified item. See
* {@link AccessibilityNodeInfoCompat#performAction(int, Bundle)}.
* <p>
* The helper class automatically handles focus management resulting from
* {@link AccessibilityNodeInfoCompat#ACTION_ACCESSIBILITY_FOCUS} and
* {@link AccessibilityNodeInfoCompat#ACTION_CLEAR_ACCESSIBILITY_FOCUS}, so
* typically a developer only needs to handle actions added manually in the
* {{@link #populateNodeForItem(Object, AccessibilityNodeInfoCompat)}
* method.
* </p>
*
* @param item The item on which to perform the action.
* @param action The accessibility action to perform.
* @param arguments Arguments for the action, or optionally {@code null}.
* @return {@code true} if the action was performed successfully.
*/
protected abstract boolean performActionForItem(T item, int action, Bundle arguments);
/**
* Populates an event with information about the specified item.
* <p>
* At a minimum, a developer must populate the event text by doing one of
* the following:
* <ul>
* <li>appending text to {@link AccessibilityEvent#getText()}</li>
* <li>populating a description with
* {@link AccessibilityEvent#setContentDescription(CharSequence)}</li>
* </ul>
* </p>
*
* @param item The item for which to populate the event.
* @param event The event to populate.
*/
protected abstract void populateEventForItem(T item, AccessibilityEvent event);
/**
* Populates a node with information about the specified item.
* <p>
* At a minimum, a developer must:
* <ul>
* <li>populate the event text using
* {@link AccessibilityNodeInfoCompat#setText(CharSequence)} or
* {@link AccessibilityNodeInfoCompat#setContentDescription(CharSequence)}
* </li>
* <li>set the item's parent-relative bounds using
* {@link AccessibilityNodeInfoCompat#setBoundsInParent(Rect)}
* </ul>
*
* @param item The item for which to populate the node.
* @param node The node to populate.
*/
protected abstract void populateNodeForItem(T item, AccessibilityNodeInfoCompat node);
/**
* Populates a list with the parent view's visible items.
* <p>
* The result of this method is cached until the developer calls
* {@link #invalidateParent()}.
* </p>
*
* @param items The list to populate with visible items.
*/
protected abstract void getVisibleItems(List<T> items);
/**
* Returns the item under the specified parent-relative coordinates.
*
* @param x The parent-relative x coordinate.
* @param y The parent-relative y coordinate.
* @return The item under coordinates (x,y).
*/
protected abstract T getItemAt(float x, float y);
/**
* Returns the unique identifier for an item. If the specified item does not
* exist, returns {@link #INVALID_ID}.
* <p>
* This result of this method must be consistent with
* {@link #getItemForId(int)}.
* </p>
*
* @param item The item whose identifier to return.
* @return A unique identifier, or {@link #INVALID_ID}.
*/
protected abstract int getIdForItem(T item);
/**
* Returns the item for a unique identifier. If the specified item does not
* exist, returns {@code null}.
*
* @param id The identifier for the item to return.
* @return An item, or {@code null}.
*/
protected abstract T getItemForId(int id);
}
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment