java/src/com/android/inputmethod/accessibility/KeyboardAccessibilityDelegate.java - platform/packages/inputmethods/LatinIME - Git at Google

 /*
  * Copyright (C) 2011 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.inputmethod.accessibility;

 import android.content.Context;
 import android.os.SystemClock;
 import androidx.core.view.AccessibilityDelegateCompat;
 import androidx.core.view.ViewCompat;
 import androidx.core.view.accessibility.AccessibilityNodeInfoCompat;
 import android.util.Log;
 import android.view.MotionEvent;
 import android.view.View;
 import android.view.ViewParent;
 import android.view.accessibility.AccessibilityEvent;

 import com.android.inputmethod.keyboard.Key;
 import com.android.inputmethod.keyboard.KeyDetector;
 import com.android.inputmethod.keyboard.Keyboard;
 import com.android.inputmethod.keyboard.KeyboardView;

 /**
  * This class represents a delegate that can be registered in a class that extends
  * {@link KeyboardView} to enhance accessibility support via composition rather via inheritance.
  *
  * To implement accessibility mode, the target keyboard view has to:<p>
  * - Call {@link #setKeyboard(Keyboard)} when a new keyboard is set to the keyboard view.
  * - Dispatch a hover event by calling {@link #onHoverEnter(MotionEvent)}.
  *
  * @param <KV> The keyboard view class type.
  */
 public class KeyboardAccessibilityDelegate<KV extends KeyboardView>
         extends AccessibilityDelegateCompat {
     private static final String TAG = KeyboardAccessibilityDelegate.class.getSimpleName();
     protected static final boolean DEBUG_HOVER = false;

     protected final KV mKeyboardView;
     protected final KeyDetector mKeyDetector;
     private Keyboard mKeyboard;
     private KeyboardAccessibilityNodeProvider<KV> mAccessibilityNodeProvider;
     private Key mLastHoverKey;

     public static final int HOVER_EVENT_POINTER_ID = 0;

     public KeyboardAccessibilityDelegate(final KV keyboardView, final KeyDetector keyDetector) {
         super();
         mKeyboardView = keyboardView;
         mKeyDetector = keyDetector;

         // Ensure that the view has an accessibility delegate.
         ViewCompat.setAccessibilityDelegate(keyboardView, this);
     }

     /**
      * Called when the keyboard layout changes.
      * <p>
      * <b>Note:</b> This method will be called even if accessibility is not
      * enabled.
      * @param keyboard The keyboard that is being set to the wrapping view.
      */
     public void setKeyboard(final Keyboard keyboard) {
         if (keyboard == null) {
             return;
         }
         if (mAccessibilityNodeProvider != null) {
             mAccessibilityNodeProvider.setKeyboard(keyboard);
         }
         mKeyboard = keyboard;
     }

     protected final Keyboard getKeyboard() {
         return mKeyboard;
     }

     protected final void setLastHoverKey(final Key key) {
         mLastHoverKey = key;
     }

     protected final Key getLastHoverKey() {
         return mLastHoverKey;
     }

     /**
      * Sends a window state change event with the specified string resource id.
      *
      * @param resId The string resource id of the text to send with the event.
      */
     protected void sendWindowStateChanged(final int resId) {
         if (resId == 0) {
             return;
         }
         final Context context = mKeyboardView.getContext();
         sendWindowStateChanged(context.getString(resId));
     }

     /**
      * Sends a window state change event with the specified text.
      *
      * @param text The text to send with the event.
      */
     protected void sendWindowStateChanged(final String text) {
         final AccessibilityEvent stateChange = AccessibilityEvent.obtain(
                 AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED);
         mKeyboardView.onInitializeAccessibilityEvent(stateChange);
         stateChange.getText().add(text);
         stateChange.setContentDescription(null);

         final ViewParent parent = mKeyboardView.getParent();
         if (parent != null) {
             parent.requestSendAccessibilityEvent(mKeyboardView, stateChange);
         }
     }

     /**
      * Delegate method for View.getAccessibilityNodeProvider(). This method is called in SDK
      * version 15 (Build.VERSION_CODES.ICE_CREAM_SANDWICH_MR1) and higher to obtain the virtual
      * node hierarchy provider.
      *
      * @param host The host view for the provider.
      * @return The accessibility node provider for the current keyboard.
      */
     @Override
     public KeyboardAccessibilityNodeProvider<KV> getAccessibilityNodeProvider(final View host) {
         return getAccessibilityNodeProvider();
     }

     /**
      * @return A lazily-instantiated node provider for this view delegate.
      */
     protected KeyboardAccessibilityNodeProvider<KV> getAccessibilityNodeProvider() {
         // Instantiate the provide only when requested. Since the system
         // will call this method multiple times it is a good practice to
         // cache the provider instance.
         if (mAccessibilityNodeProvider == null) {
             mAccessibilityNodeProvider =
                     new KeyboardAccessibilityNodeProvider<>(mKeyboardView, this);
         }
         return mAccessibilityNodeProvider;
     }

     /**
      * Get a key that a hover event is on.
      *
      * @param event The hover event.
      * @return key The key that the <code>event</code> is on.
      */
     protected final Key getHoverKeyOf(final MotionEvent event) {
         final int actionIndex = event.getActionIndex();
         final int x = (int)event.getX(actionIndex);
         final int y = (int)event.getY(actionIndex);
         return mKeyDetector.detectHitKey(x, y);
     }

     /**
      * Receives hover events when touch exploration is turned on in SDK versions ICS and higher.
      *
      * @param event The hover event.
      * @return {@code true} if the event is handled.
      */
     public boolean onHoverEvent(final MotionEvent event) {
         switch (event.getActionMasked()) {
         case MotionEvent.ACTION_HOVER_ENTER:
             onHoverEnter(event);
             break;
         case MotionEvent.ACTION_HOVER_MOVE:
             onHoverMove(event);
             break;
         case MotionEvent.ACTION_HOVER_EXIT:
             onHoverExit(event);
             break;
         default:
             Log.w(getClass().getSimpleName(), "Unknown hover event: " + event);
             break;
         }
         return true;
     }

     /**
      * Process {@link MotionEvent#ACTION_HOVER_ENTER} event.
      *
      * @param event A hover enter event.
      */
     protected void onHoverEnter(final MotionEvent event) {
         final Key key = getHoverKeyOf(event);
         if (DEBUG_HOVER) {
             Log.d(TAG, "onHoverEnter: key=" + key);
         }
         if (key != null) {
             onHoverEnterTo(key);
         }
         setLastHoverKey(key);
     }

     /**
      * Process {@link MotionEvent#ACTION_HOVER_MOVE} event.
      *
      * @param event A hover move event.
      */
     protected void onHoverMove(final MotionEvent event) {
         final Key lastKey = getLastHoverKey();
         final Key key = getHoverKeyOf(event);
         if (key != lastKey) {
             if (lastKey != null) {
                 onHoverExitFrom(lastKey);
             }
             if (key != null) {
                 onHoverEnterTo(key);
             }
         }
         if (key != null) {
             onHoverMoveWithin(key);
         }
         setLastHoverKey(key);
     }

     /**
      * Process {@link MotionEvent#ACTION_HOVER_EXIT} event.
      *
      * @param event A hover exit event.
      */
     protected void onHoverExit(final MotionEvent event) {
         final Key lastKey = getLastHoverKey();
         if (DEBUG_HOVER) {
             Log.d(TAG, "onHoverExit: key=" + getHoverKeyOf(event) + " last=" + lastKey);
         }
         if (lastKey != null) {
             onHoverExitFrom(lastKey);
         }
         final Key key = getHoverKeyOf(event);
         // Make sure we're not getting an EXIT event because the user slid
         // off the keyboard area, then force a key press.
         if (key != null) {
             onHoverExitFrom(key);
         }
         setLastHoverKey(null);
     }

     /**
      * Perform click on a key.
      *
      * @param key A key to be registered.
      */
     public void performClickOn(final Key key) {
         if (DEBUG_HOVER) {
             Log.d(TAG, "performClickOn: key=" + key);
         }
         simulateTouchEvent(MotionEvent.ACTION_DOWN, key);
         simulateTouchEvent(MotionEvent.ACTION_UP, key);
     }

     /**
      * Simulating a touch event by injecting a synthesized touch event into {@link KeyboardView}.
      *
      * @param touchAction The action of the synthesizing touch event.
      * @param key The key that a synthesized touch event is on.
      */
     private void simulateTouchEvent(final int touchAction, final Key key) {
         final int x = key.getHitBox().centerX();
         final int y = key.getHitBox().centerY();
         final long eventTime = SystemClock.uptimeMillis();
         final MotionEvent touchEvent = MotionEvent.obtain(
                 eventTime, eventTime, touchAction, x, y, 0 /* metaState */);
         mKeyboardView.onTouchEvent(touchEvent);
         touchEvent.recycle();
     }

     /**
      * Handles a hover enter event on a key.
      *
      * @param key The currently hovered key.
      */
     protected void onHoverEnterTo(final Key key) {
         if (DEBUG_HOVER) {
             Log.d(TAG, "onHoverEnterTo: key=" + key);
         }
         key.onPressed();
         mKeyboardView.invalidateKey(key);
         final KeyboardAccessibilityNodeProvider<KV> provider = getAccessibilityNodeProvider();
         provider.onHoverEnterTo(key);
         provider.performActionForKey(key, AccessibilityNodeInfoCompat.ACTION_ACCESSIBILITY_FOCUS);
     }

     /**
      * Handles a hover move event on a key.
      *
      * @param key The currently hovered key.
      */
     protected void onHoverMoveWithin(final Key key) { }

     /**
      * Handles a hover exit event on a key.
      *
      * @param key The currently hovered key.
      */
     protected void onHoverExitFrom(final Key key) {
         if (DEBUG_HOVER) {
             Log.d(TAG, "onHoverExitFrom: key=" + key);
         }
         key.onReleased();
         mKeyboardView.invalidateKey(key);
         final KeyboardAccessibilityNodeProvider<KV> provider = getAccessibilityNodeProvider();
         provider.onHoverExitFrom(key);
     }

     /**
      * Perform long click on a key.
      *
      * @param key A key to be long pressed on.
      */
     public void performLongClickOn(final Key key) {
         // A extended class should override this method to implement long press.
     }
 }
	/*
	* Copyright (C) 2011 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.inputmethod.accessibility;

	import android.content.Context;
	import android.os.SystemClock;
	import androidx.core.view.AccessibilityDelegateCompat;
	import androidx.core.view.ViewCompat;
	import androidx.core.view.accessibility.AccessibilityNodeInfoCompat;
	import android.util.Log;
	import android.view.MotionEvent;
	import android.view.View;
	import android.view.ViewParent;
	import android.view.accessibility.AccessibilityEvent;

	import com.android.inputmethod.keyboard.Key;
	import com.android.inputmethod.keyboard.KeyDetector;
	import com.android.inputmethod.keyboard.Keyboard;
	import com.android.inputmethod.keyboard.KeyboardView;

	/**
	* This class represents a delegate that can be registered in a class that extends
	* {@link KeyboardView} to enhance accessibility support via composition rather via inheritance.
	*
	* To implement accessibility mode, the target keyboard view has to:<p>
	* - Call {@link #setKeyboard(Keyboard)} when a new keyboard is set to the keyboard view.
	* - Dispatch a hover event by calling {@link #onHoverEnter(MotionEvent)}.
	*
	* @param <KV> The keyboard view class type.
	*/
	public class KeyboardAccessibilityDelegate<KV extends KeyboardView>
	extends AccessibilityDelegateCompat {
	private static final String TAG = KeyboardAccessibilityDelegate.class.getSimpleName();
	protected static final boolean DEBUG_HOVER = false;

	protected final KV mKeyboardView;
	protected final KeyDetector mKeyDetector;
	private Keyboard mKeyboard;
	private KeyboardAccessibilityNodeProvider<KV> mAccessibilityNodeProvider;
	private Key mLastHoverKey;

	public static final int HOVER_EVENT_POINTER_ID = 0;

	public KeyboardAccessibilityDelegate(final KV keyboardView, final KeyDetector keyDetector) {
	super();
	mKeyboardView = keyboardView;
	mKeyDetector = keyDetector;

	// Ensure that the view has an accessibility delegate.
	ViewCompat.setAccessibilityDelegate(keyboardView, this);
	}

	/**
	* Called when the keyboard layout changes.
	* <p>
	* <b>Note:</b> This method will be called even if accessibility is not
	* enabled.
	* @param keyboard The keyboard that is being set to the wrapping view.
	*/
	public void setKeyboard(final Keyboard keyboard) {
	if (keyboard == null) {
	return;
	}
	if (mAccessibilityNodeProvider != null) {
	mAccessibilityNodeProvider.setKeyboard(keyboard);
	}
	mKeyboard = keyboard;
	}

	protected final Keyboard getKeyboard() {
	return mKeyboard;
	}

	protected final void setLastHoverKey(final Key key) {
	mLastHoverKey = key;
	}

	protected final Key getLastHoverKey() {
	return mLastHoverKey;
	}

	/**
	* Sends a window state change event with the specified string resource id.
	*
	* @param resId The string resource id of the text to send with the event.
	*/
	protected void sendWindowStateChanged(final int resId) {
	if (resId == 0) {
	return;
	}
	final Context context = mKeyboardView.getContext();
	sendWindowStateChanged(context.getString(resId));
	}

	/**
	* Sends a window state change event with the specified text.
	*
	* @param text The text to send with the event.
	*/
	protected void sendWindowStateChanged(final String text) {
	final AccessibilityEvent stateChange = AccessibilityEvent.obtain(
	AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED);
	mKeyboardView.onInitializeAccessibilityEvent(stateChange);
	stateChange.getText().add(text);
	stateChange.setContentDescription(null);

	final ViewParent parent = mKeyboardView.getParent();
	if (parent != null) {
	parent.requestSendAccessibilityEvent(mKeyboardView, stateChange);
	}
	}

	/**
	* Delegate method for View.getAccessibilityNodeProvider(). This method is called in SDK
	* version 15 (Build.VERSION_CODES.ICE_CREAM_SANDWICH_MR1) and higher to obtain the virtual
	* node hierarchy provider.
	*
	* @param host The host view for the provider.
	* @return The accessibility node provider for the current keyboard.
	*/
	@Override
	public KeyboardAccessibilityNodeProvider<KV> getAccessibilityNodeProvider(final View host) {
	return getAccessibilityNodeProvider();
	}

	/**
	* @return A lazily-instantiated node provider for this view delegate.
	*/
	protected KeyboardAccessibilityNodeProvider<KV> getAccessibilityNodeProvider() {
	// Instantiate the provide only when requested. Since the system
	// will call this method multiple times it is a good practice to
	// cache the provider instance.
	if (mAccessibilityNodeProvider == null) {
	mAccessibilityNodeProvider =
	new KeyboardAccessibilityNodeProvider<>(mKeyboardView, this);
	}
	return mAccessibilityNodeProvider;
	}

	/**
	* Get a key that a hover event is on.
	*
	* @param event The hover event.
	* @return key The key that the <code>event</code> is on.
	*/
	protected final Key getHoverKeyOf(final MotionEvent event) {
	final int actionIndex = event.getActionIndex();
	final int x = (int)event.getX(actionIndex);
	final int y = (int)event.getY(actionIndex);
	return mKeyDetector.detectHitKey(x, y);
	}

	/**
	* Receives hover events when touch exploration is turned on in SDK versions ICS and higher.
	*
	* @param event The hover event.
	* @return {@code true} if the event is handled.
	*/
	public boolean onHoverEvent(final MotionEvent event) {
	switch (event.getActionMasked()) {
	case MotionEvent.ACTION_HOVER_ENTER:
	onHoverEnter(event);
	break;
	case MotionEvent.ACTION_HOVER_MOVE:
	onHoverMove(event);
	break;
	case MotionEvent.ACTION_HOVER_EXIT:
	onHoverExit(event);
	break;
	default:
	Log.w(getClass().getSimpleName(), "Unknown hover event: " + event);
	break;
	}
	return true;
	}

	/**
	* Process {@link MotionEvent#ACTION_HOVER_ENTER} event.
	*
	* @param event A hover enter event.
	*/
	protected void onHoverEnter(final MotionEvent event) {
	final Key key = getHoverKeyOf(event);
	if (DEBUG_HOVER) {
	Log.d(TAG, "onHoverEnter: key=" + key);
	}
	if (key != null) {
	onHoverEnterTo(key);
	}
	setLastHoverKey(key);
	}

	/**
	* Process {@link MotionEvent#ACTION_HOVER_MOVE} event.
	*
	* @param event A hover move event.
	*/
	protected void onHoverMove(final MotionEvent event) {
	final Key lastKey = getLastHoverKey();
	final Key key = getHoverKeyOf(event);
	if (key != lastKey) {
	if (lastKey != null) {
	onHoverExitFrom(lastKey);
	}
	if (key != null) {
	onHoverEnterTo(key);
	}
	}
	if (key != null) {
	onHoverMoveWithin(key);
	}
	setLastHoverKey(key);
	}

	/**
	* Process {@link MotionEvent#ACTION_HOVER_EXIT} event.
	*
	* @param event A hover exit event.
	*/
	protected void onHoverExit(final MotionEvent event) {
	final Key lastKey = getLastHoverKey();
	if (DEBUG_HOVER) {
	Log.d(TAG, "onHoverExit: key=" + getHoverKeyOf(event) + " last=" + lastKey);
	}
	if (lastKey != null) {
	onHoverExitFrom(lastKey);
	}
	final Key key = getHoverKeyOf(event);
	// Make sure we're not getting an EXIT event because the user slid
	// off the keyboard area, then force a key press.
	if (key != null) {
	onHoverExitFrom(key);
	}
	setLastHoverKey(null);
	}

	/**
	* Perform click on a key.
	*
	* @param key A key to be registered.
	*/
	public void performClickOn(final Key key) {
	if (DEBUG_HOVER) {
	Log.d(TAG, "performClickOn: key=" + key);
	}
	simulateTouchEvent(MotionEvent.ACTION_DOWN, key);
	simulateTouchEvent(MotionEvent.ACTION_UP, key);
	}

	/**
	* Simulating a touch event by injecting a synthesized touch event into {@link KeyboardView}.
	*
	* @param touchAction The action of the synthesizing touch event.
	* @param key The key that a synthesized touch event is on.
	*/
	private void simulateTouchEvent(final int touchAction, final Key key) {
	final int x = key.getHitBox().centerX();
	final int y = key.getHitBox().centerY();
	final long eventTime = SystemClock.uptimeMillis();
	final MotionEvent touchEvent = MotionEvent.obtain(
	eventTime, eventTime, touchAction, x, y, 0 /* metaState */);
	mKeyboardView.onTouchEvent(touchEvent);
	touchEvent.recycle();
	}

	/**
	* Handles a hover enter event on a key.
	*
	* @param key The currently hovered key.
	*/
	protected void onHoverEnterTo(final Key key) {
	if (DEBUG_HOVER) {
	Log.d(TAG, "onHoverEnterTo: key=" + key);
	}
	key.onPressed();
	mKeyboardView.invalidateKey(key);
	final KeyboardAccessibilityNodeProvider<KV> provider = getAccessibilityNodeProvider();
	provider.onHoverEnterTo(key);
	provider.performActionForKey(key, AccessibilityNodeInfoCompat.ACTION_ACCESSIBILITY_FOCUS);
	}

	/**
	* Handles a hover move event on a key.
	*
	* @param key The currently hovered key.
	*/
	protected void onHoverMoveWithin(final Key key) { }

	/**
	* Handles a hover exit event on a key.
	*
	* @param key The currently hovered key.
	*/
	protected void onHoverExitFrom(final Key key) {
	if (DEBUG_HOVER) {
	Log.d(TAG, "onHoverExitFrom: key=" + key);
	}
	key.onReleased();
	mKeyboardView.invalidateKey(key);
	final KeyboardAccessibilityNodeProvider<KV> provider = getAccessibilityNodeProvider();
	provider.onHoverExitFrom(key);
	}

	/**
	* Perform long click on a key.
	*
	* @param key A key to be long pressed on.
	*/
	public void performLongClickOn(final Key key) {
	// A extended class should override this method to implement long press.
	}
	}