Rename to Kelar Keyboard (org.kelar.inputmethod.latin)

1 files changed, 326 insertions, 0 deletions

diff --git a/java/src/org/kelar/inputmethod/accessibility/KeyboardAccessibilityDelegate.java b/java/src/org/kelar/inputmethod/accessibility/KeyboardAccessibilityDelegate.java
new file mode 100644
index 000000000..9e6275d56
--- /dev/null
+++ b/java/src/org/kelar/inputmethod/accessibility/KeyboardAccessibilityDelegate.java
@@ -0,0 +1,326 @@
+/*
+ * 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 org.kelar.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 org.kelar.inputmethod.keyboard.Key;
+import org.kelar.inputmethod.keyboard.KeyDetector;
+import org.kelar.inputmethod.keyboard.Keyboard;
+import org.kelar.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.
+    }
+}