Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Revert "Revert "Scribe in IMF: startStylusHandwriting & lifecycl..."

Browse Source 
Revert^2 "CTS for Stylus Handwriting lifecycle"

493b8d7d3b4d43e483c03b155d38057e3eacd3c9

Reason: Fix API signature related issues by making newly introduced
 methods in InputMethod.java default

Bug: 213976598
Bug: 203086136
Test: atest StylusHandwritingTest
Test: atest SignatureTest#testSignature

Change-Id: Idfd5d1f84e66e3a19ef384589b4892adb91f8066
This commit is contained in:
Taran Singh
2021-11-16 01:35:47 +00:00
parent 11a249be90
commit 94324080af
14 changed files with 492 additions and 30 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
core/java/android/inputmethodservice/IInputMethodWrapper.java
View File

@@ -18,6 +18,7 @@ package android.inputmethodservice;
import android.annotation.BinderThread;
import android.annotation.MainThread;
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.compat.annotation.UnsupportedAppUsage;
import android.content.Context;
@@ -29,6 +30,7 @@ import android.os.RemoteException;
import android.os.ResultReceiver;
import android.util.Log;
import android.view.InputChannel;
import android.view.MotionEvent;
import android.view.inputmethod.EditorInfo;
import android.view.inputmethod.InputBinding;
import android.view.inputmethod.InputConnection;
@@ -50,6 +52,7 @@ import com.android.internal.view.InlineSuggestionsRequestInfo;
import java.io.FileDescriptor;
import java.io.PrintWriter;
import java.lang.ref.WeakReference;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
@@ -74,6 +77,8 @@ class IInputMethodWrapper extends IInputMethod.Stub
private static final int DO_HIDE_SOFT_INPUT = 70;
private static final int DO_CHANGE_INPUTMETHOD_SUBTYPE = 80;
private static final int DO_CREATE_INLINE_SUGGESTIONS_REQUEST = 90;
private static final int DO_CAN_START_STYLUS_HANDWRITING = 100;
private static final int DO_START_STYLUS_HANDWRITING = 110;
final WeakReference<InputMethodServiceInternal> mTarget;
final Context mContext;
@@ -169,7 +174,8 @@ class IInputMethodWrapper extends IInputMethod.Stub
SomeArgs args = (SomeArgs) msg.obj;
try {
inputMethod.initializeInternal((IBinder) args.arg1,
(IInputMethodPrivilegedOperations) args.arg2, msg.arg1);
(IInputMethodPrivilegedOperations) args.arg2, msg.arg1,
(boolean) args.arg3);
} finally {
args.recycle();
}
@@ -229,13 +235,25 @@ class IInputMethodWrapper extends IInputMethod.Stub
case DO_CHANGE_INPUTMETHOD_SUBTYPE:
inputMethod.changeInputMethodSubtype((InputMethodSubtype)msg.obj);
return;
case DO_CREATE_INLINE_SUGGESTIONS_REQUEST:
case DO_CREATE_INLINE_SUGGESTIONS_REQUEST: {
final SomeArgs args = (SomeArgs) msg.obj;
inputMethod.onCreateInlineSuggestionsRequest(
(InlineSuggestionsRequestInfo) args.arg1,
(IInlineSuggestionsRequestCallback) args.arg2);
args.recycle();
return;
}
case DO_CAN_START_STYLUS_HANDWRITING: {
inputMethod.canStartStylusHandwriting(msg.arg1);
return;
}
case DO_START_STYLUS_HANDWRITING: {
final SomeArgs args = (SomeArgs) msg.obj;
inputMethod.startStylusHandwriting((InputChannel) args.arg1,
(List<MotionEvent>) args.arg2);
args.recycle();
return;
}
}
Log.w(TAG, "Unhandled message code: " + msg.what);
@@ -272,9 +290,10 @@ class IInputMethodWrapper extends IInputMethod.Stub
@BinderThread
@Override
public void initializeInternal(IBinder token, IInputMethodPrivilegedOperations privOps,
int configChanges) {
int configChanges, boolean stylusHwSupported) {
mCaller.executeOrSendMessage(
mCaller.obtainMessageIOO(DO_INITIALIZE_INTERNAL, configChanges, token, privOps));
mCaller.obtainMessageIOOO(
DO_INITIALIZE_INTERNAL, configChanges, token, privOps, stylusHwSupported));
}
@BinderThread
@@ -383,4 +402,21 @@ class IInputMethodWrapper extends IInputMethod.Stub
mCaller.executeOrSendMessage(mCaller.obtainMessageO(DO_CHANGE_INPUTMETHOD_SUBTYPE,
subtype));
}
@BinderThread
@Override
public void canStartStylusHandwriting(int requestId)
throws RemoteException {
mCaller.executeOrSendMessage(
mCaller.obtainMessageI(DO_CAN_START_STYLUS_HANDWRITING, requestId));
}
@BinderThread
@Override
public void startStylusHandwriting(@NonNull InputChannel channel,
@Nullable List<MotionEvent> stylusEvents)
throws RemoteException {
mCaller.executeOrSendMessage(
mCaller.obtainMessageOO(DO_START_STYLUS_HANDWRITING, channel, stylusEvents));
}
}

88
core/java/android/inputmethodservice/InkWindow.java Normal file
View File

@@ -0,0 +1,88 @@
/*
* Copyright (C) 2021 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 android.inputmethodservice;
import static android.view.WindowManager.LayoutParams;
import static android.view.WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN;
import static android.view.WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS;
import static android.view.WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE;
import static android.view.WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE;
import android.annotation.NonNull;
import android.content.Context;
import android.os.IBinder;
import android.util.Slog;
import android.view.View;
import android.view.WindowManager;
import com.android.internal.policy.PhoneWindow;
/**
* Window of type {@code LayoutParams.TYPE_INPUT_METHOD_DIALOG} for drawing
* Handwriting Ink on screen.
* @hide
*/
final class InkWindow extends PhoneWindow {
private final WindowManager mWindowManager;
public InkWindow(@NonNull Context context) {
super(context);
setType(LayoutParams.TYPE_INPUT_METHOD);
final LayoutParams attrs = getAttributes();
attrs.layoutInDisplayCutoutMode = LayoutParams.LAYOUT_IN_DISPLAY_CUTOUT_MODE_ALWAYS;
attrs.setFitInsetsTypes(0);
setAttributes(attrs);
// Ink window is not touchable with finger.
addFlags(FLAG_LAYOUT_IN_SCREEN | FLAG_LAYOUT_NO_LIMITS | FLAG_NOT_TOUCHABLE
| FLAG_NOT_FOCUSABLE);
setBackgroundDrawableResource(android.R.color.transparent);
setLayout(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
mWindowManager = context.getSystemService(WindowManager.class);
}
/**
* Method to show InkWindow on screen.
* Emulates internal behavior similar to Dialog.show().
*/
void show() {
if (getDecorView() == null) {
Slog.i(InputMethodService.TAG, "DecorView is not set for InkWindow. show() failed.");
return;
}
getDecorView().setVisibility(View.VISIBLE);
mWindowManager.addView(getDecorView(), getAttributes());
}
/**
* Method to hide InkWindow from screen.
* Emulates internal behavior similar to Dialog.hide().
* @param remove set {@code true} to remove InkWindow surface completely.
*/
void hide(boolean remove) {
if (getDecorView() != null) {
getDecorView().setVisibility(remove ? View.GONE : View.INVISIBLE);
}
}
void setToken(@NonNull IBinder token) {
WindowManager.LayoutParams lp = getAttributes();
lp.token = token;
setAttributes(lp);
}
}

133
core/java/android/inputmethodservice/InputMethodService.java
View File

@@ -94,6 +94,7 @@ import android.util.PrintWriterPrinter;
import android.util.Printer;
import android.util.proto.ProtoOutputStream;
import android.view.Gravity;
import android.view.InputChannel;
import android.view.KeyCharacterMap;
import android.view.KeyEvent;
import android.view.LayoutInflater;
@@ -119,6 +120,7 @@ import android.view.inputmethod.InputConnection;
import android.view.inputmethod.InputContentInfo;
import android.view.inputmethod.InputMethod;
import android.view.inputmethod.InputMethodEditorTraceProto.InputMethodServiceTraceProto;
import android.view.inputmethod.InputMethodInfo;
import android.view.inputmethod.InputMethodManager;
import android.view.inputmethod.InputMethodSubtype;
import android.widget.FrameLayout;
@@ -142,6 +144,7 @@ import java.io.PrintWriter;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
/**
@@ -520,11 +523,15 @@ public class InputMethodService extends AbstractInputMethodService {
private boolean mAutomotiveHideNavBarForKeyboard;
private boolean mIsAutomotive;
private boolean mHandwritingStarted;
private Handler mHandler;
private boolean mImeSurfaceScheduledForRemoval;
private ImsConfigurationTracker mConfigTracker = new ImsConfigurationTracker();
private boolean mDestroyed;
/** Stylus handwriting Ink window. */
private InkWindow mInkWindow;
/**
* An opaque {@link Binder} token of window requesting {@link InputMethodImpl#showSoftInput}
* The original app window token is passed from client app window.
@@ -599,7 +606,8 @@ public class InputMethodService extends AbstractInputMethodService {
@MainThread
@Override
public final void initializeInternal(@NonNull IBinder token,
IInputMethodPrivilegedOperations privilegedOperations, int configChanges) {
IInputMethodPrivilegedOperations privilegedOperations, int configChanges,
boolean stylusHwSupported) {
if (mDestroyed) {
Log.i(TAG, "The InputMethodService has already onDestroyed()."
+ "Ignore the initialization.");
@@ -609,6 +617,9 @@ public class InputMethodService extends AbstractInputMethodService {
mConfigTracker.onInitialize(configChanges);
mPrivOps.set(privilegedOperations);
InputMethodPrivilegedOperationsRegistry.put(token, mPrivOps);
if (stylusHwSupported) {
mInkWindow = new InkWindow(mWindow.getContext());
}
attachToken(token);
Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);
}
@@ -641,6 +652,9 @@ public class InputMethodService extends AbstractInputMethodService {
attachToWindowToken(token);
mToken = token;
mWindow.setToken(token);
if (mInkWindow != null) {
mInkWindow.setToken(token);
}
}
/**
@@ -822,6 +836,49 @@ public class InputMethodService extends AbstractInputMethodService {
Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);
}
/**
* {@inheritDoc}
* @hide
*/
@Override
public void canStartStylusHandwriting(int requestId) {
if (DEBUG) Log.v(TAG, "canStartStylusHandwriting()");
if (mHandwritingStarted) {
Log.d(TAG, "There is an ongoing Handwriting session. ignoring.");
return;
}
if (!mInputStarted) {
Log.d(TAG, "Input should have started before starting Stylus handwriting.");
return;
}
if (onStartStylusHandwriting()) {
mPrivOps.onStylusHandwritingReady(requestId);
} else {
Log.i(TAG, "IME is not ready. Can't start Stylus Handwriting");
}
}
/**
* {@inheritDoc}
* @hide
*/
@MainThread
@Override
public void startStylusHandwriting(
@NonNull InputChannel channel, @Nullable List<MotionEvent> stylusEvents) {
if (DEBUG) Log.v(TAG, "startStylusHandwriting()");
if (mHandwritingStarted) {
return;
}
mHandwritingStarted = true;
mShowInputRequested = false;
mInkWindow.show();
// TODO: deliver previous @param stylusEvents
// TODO: create spy receiver for @param channel
}
/**
* {@inheritDoc}
*/
@@ -2192,6 +2249,77 @@ public class InputMethodService extends AbstractInputMethodService {
}
}
/**
* Called when an app requests stylus handwriting
* {@link InputMethodManager#startStylusHandwriting(View)}.
*
* This will always be preceded by {@link #onStartInput(EditorInfo, boolean)} for the
* {@link EditorInfo} and {@link InputConnection} for which stylus handwriting is being
* requested.
*
* If the IME supports handwriting for the current input, it should return {@code true},
* ensure its inking views are attached to the {@link #getStylusHandwritingWindow()}, and handle
* stylus input received on the ink window via {@link #getCurrentInputConnection()}.
* @return {@code true} if IME can honor the request, {@code false} if IME cannot at this time.
*/
public boolean onStartStylusHandwriting() {
// Intentionally empty
return false;
}
/**
* Called when the current stylus handwriting session was finished (either by the system or
* via {@link #finishStylusHandwriting()}.
*
* When this is called, the ink window has been made invisible, and the IME no longer
* intercepts handwriting-related {@code MotionEvent}s.
*/
public void onFinishStylusHandwriting() {
// Intentionally empty
}
/**
* Returns the stylus handwriting inking window.
* IMEs supporting stylus input are expected to attach their inking views to this
* window (e.g. with {@link Window#setContentView(View)} )). Handwriting-related
* {@link MotionEvent}s are dispatched to the attached view hierarchy.
*
* Note: This returns {@code null} if IME doesn't support stylus handwriting
* i.e. if {@link InputMethodInfo#supportsStylusHandwriting()} is false.
* This method should be called after {@link #onStartStylusHandwriting()}.
* @see #onStartStylusHandwriting()
*/
@Nullable
public final Window getStylusHandwritingWindow() {
return mInkWindow;
}
/**
* Finish the current stylus handwriting session.
*
* This dismisses the {@link #getStylusHandwritingWindow ink window} and stops intercepting
* stylus {@code MotionEvent}s.
*
* Note for IME developers: Call this method at any time to finish current handwriting session.
* Generally, this should be invoked after a short timeout, giving the user enough time
* to start the next stylus stroke, if any.
*
* Handwriting session will be finished by framework on next {@link #onFinishInput()}.
*/
public final void finishStylusHandwriting() {
if (DEBUG) Log.v(TAG, "finishStylusHandwriting()");
if (mInkWindow == null) {
return;
}
if (!mHandwritingStarted) {
return;
}
mHandwritingStarted = false;
mInkWindow.hide(false /* remove */);
onFinishStylusHandwriting();
}
/**
* The system has decided that it may be time to show your input method.
* This is called due to a corresponding call to your
@@ -2461,6 +2589,9 @@ public class InputMethodService extends AbstractInputMethodService {
mInputStarted = false;
mStartedInputConnection = null;
mCurCompletions = null;
if (mInkWindow != null) {
finishStylusHandwriting();
}
}
void doStartInput(InputConnection ic, EditorInfo attribute, boolean restarting) {