tests/framework/base/windowmanager/src/android/server/wm/WindowInsetsAnimationSynchronicityTests.java - platform/cts - Git at Google

 /*
  * Copyright (C) 2020 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.server.wm;

 import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
 import static android.app.WindowConfiguration.WINDOWING_MODE_UNDEFINED;
 import static android.content.Intent.FLAG_ACTIVITY_NEW_TASK;
 import static android.server.wm.ActivityManagerTestBase.executeShellCommand;
 import static android.server.wm.WindowInsetsAnimationUtils.requestControlThenTransitionToVisibility;
 import static android.view.Display.DEFAULT_DISPLAY;
 import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
 import static android.view.WindowInsets.Type.ime;
 import static android.view.WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN;

 import static androidx.test.platform.app.InstrumentationRegistry.getInstrumentation;

 import android.app.Activity;
 import android.app.ActivityOptions;
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.graphics.Bitmap;
 import android.graphics.Canvas;
 import android.graphics.Insets;
 import android.graphics.Paint;
 import android.graphics.Rect;
 import android.inputmethodservice.InputMethodService;
 import android.os.Bundle;
 import android.platform.test.annotations.LargeTest;
 import android.provider.Settings;
 import android.server.wm.WindowInsetsAnimationControllerTests.LimitedErrorCollector;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.Window;
 import android.view.WindowInsets;
 import android.view.WindowInsetsAnimation;
 import android.view.WindowInsetsAnimation.Callback;
 import android.view.WindowInsetsController;
 import android.view.inputmethod.EditorInfo;
 import android.view.inputmethod.InputMethodManager;
 import android.widget.EditText;
 import android.widget.FrameLayout;

 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.test.platform.app.InstrumentationRegistry;
 import androidx.test.rule.ActivityTestRule;

 import com.android.compatibility.common.util.PollingCheck;
 import com.android.compatibility.common.util.SystemUtil;

 import org.junit.Rule;
 import org.junit.Test;

 import java.lang.reflect.Array;
 import java.util.List;
 import java.util.Locale;
 import java.util.function.Supplier;

 @LargeTest
 public class WindowInsetsAnimationSynchronicityTests {
     private static final int APP_COLOR = 0xff01fe10; // green
     private static final int BEHIND_IME_COLOR = 0xfffeef00; // yellow
     private static final int IME_COLOR = 0xfffe01fd; // pink

     @Rule
     public LimitedErrorCollector mErrorCollector = new LimitedErrorCollector();

     private final Context mContext = InstrumentationRegistry.getInstrumentation().getContext();

     @Test
     public void testShowAndHide_renderSynchronouslyBetweenImeWindowAndAppContent() throws Throwable {
         runTest(false /* useControlApi */);
     }

     @Test
     public void testControl_rendersSynchronouslyBetweenImeWindowAndAppContent() throws Throwable {
         runTest(true /* useControlApi */);
     }

     private void runTest(boolean useControlApi) throws Exception {
         try (ImeSession imeSession = new ImeSession(SimpleIme.getName(mContext))) {
             TestActivity activity = launchActivity();
             activity.setUseControlApi(useControlApi);
             PollingCheck.waitFor(activity::hasWindowFocus);
             activity.setEvaluator(() -> {
                 // This runs from time to time on the UI thread.
                 Bitmap screenshot = getInstrumentation().getUiAutomation().takeScreenshot();
                 final int center = screenshot.getWidth() / 2;
                 int imePositionApp = lowestPixelWithColor(APP_COLOR, 1, screenshot);
                 int contentBottomMiddle = lowestPixelWithColor(APP_COLOR, center, screenshot);
                 int behindImeBottomMiddle =
                         lowestPixelWithColor(BEHIND_IME_COLOR, center, screenshot);
                 int imePositionIme = Math.max(contentBottomMiddle, behindImeBottomMiddle);
                 if (imePositionApp != imePositionIme) {
                     mErrorCollector.addError(new AssertionError(String.format(Locale.US,
                             "IME is positioned at %d (max of %d, %d),"
                                     + " app thinks it is positioned at %d",
                             imePositionIme, contentBottomMiddle, behindImeBottomMiddle,
                             imePositionApp)));
                 }
             });
             Thread.sleep(2000);
             activity.setEvaluator(null);
         }
     }

     private TestActivity launchActivity() {
         final ActivityOptions options= ActivityOptions.makeBasic();
         options.setLaunchWindowingMode(WINDOWING_MODE_FULLSCREEN);
         final TestActivity[] activity = (TestActivity[]) Array.newInstance(TestActivity.class, 1);
         SystemUtil.runWithShellPermissionIdentity(() -> {
             activity[0] = (TestActivity) getInstrumentation().startActivitySync(
                     new Intent(getInstrumentation().getTargetContext(), TestActivity.class)
                             .addFlags(FLAG_ACTIVITY_NEW_TASK), options.toBundle());
         });
         return activity[0];
     }

     private static int lowestPixelWithColor(int color, int x, Bitmap bitmap) {
         int[] pixels = new int[bitmap.getHeight()];
         bitmap.getPixels(pixels, 0, 1, x, 0, 1, bitmap.getHeight());
         for (int y = pixels.length - 1; y >= 0; y--) {
             if (pixels[y] == color) {
                 return y;
             }
         }
         return -1;
     }

     public static class TestActivity extends Activity implements
             WindowInsetsController.OnControllableInsetsChangedListener {

         private TestView mTestView;
         private EditText mEditText;
         private Runnable mEvaluator;
         private boolean mUseControlApi;

         @Override
         protected void onCreate(@Nullable Bundle savedInstanceState) {
             super.onCreate(savedInstanceState);
             getWindow().requestFeature(Window.FEATURE_NO_TITLE);
             getWindow().setDecorFitsSystemWindows(false);
             getWindow().setSoftInputMode(SOFT_INPUT_STATE_ALWAYS_HIDDEN);
             mTestView = new TestView(this);
             mEditText = new EditText(this);
             mEditText.setImeOptions(EditorInfo.IME_FLAG_NO_FULLSCREEN);
             mTestView.addView(mEditText);
             mTestView.mEvaluator = () -> {
                 if (mEvaluator != null) {
                     mEvaluator.run();
                 }
             };
             mEditText.requestFocus();
             setContentView(mTestView);
             mEditText.getWindowInsetsController().addOnControllableInsetsChangedListener(this);
         }

         void setEvaluator(Runnable evaluator) {
             mEvaluator = evaluator;
         }

         void setUseControlApi(boolean useControlApi) {
             mUseControlApi = useControlApi;
         }

         @Override
         public void onControllableInsetsChanged(@NonNull WindowInsetsController controller,
                 int typeMask) {
             if ((typeMask & ime()) != 0) {
                 mEditText.getWindowInsetsController().removeOnControllableInsetsChangedListener(
                         this);
                 showIme();
             }
         }

         private void showIme() {
             if (mUseControlApi) {
                 requestControlThenTransitionToVisibility(mTestView.getWindowInsetsController(),
                         ime(), true);
             } else {
                 mTestView.getWindowInsetsController().show(ime());
             }
         }

         private void hideIme() {
             if (mUseControlApi) {
                 requestControlThenTransitionToVisibility(mTestView.getWindowInsetsController(),
                         ime(), false);
             } else {
                 mTestView.getWindowInsetsController().hide(ime());
             }
         }

         private static class TestView extends FrameLayout {
             private WindowInsets mLayoutInsets;
             private WindowInsets mAnimationInsets;
             private final Rect mTmpRect = new Rect();
             private final Paint mContentPaint = new Paint();

             private final Callback mInsetsCallback = new Callback(Callback.DISPATCH_MODE_STOP) {
                 @NonNull
                 @Override
                 public WindowInsets onProgress(@NonNull WindowInsets insets,
                         @NonNull List<WindowInsetsAnimation> runningAnimations) {
                     if (runningAnimations.stream().anyMatch(TestView::isImeAnimation)) {
                         mAnimationInsets = insets;
                         invalidate();
                     }
                     return WindowInsets.CONSUMED;
                 }

                 @Override
                 public void onEnd(@NonNull WindowInsetsAnimation animation) {
                     if (isImeAnimation(animation)) {
                         mAnimationInsets = null;
                         post(() -> {
                             if (mLayoutInsets.isVisible(ime())) {
                                 ((TestActivity) getContext()).hideIme();
                             } else {
                                 ((TestActivity) getContext()).showIme();
                             }
                         });

                     }
                 }
             };
             private final Runnable mRunEvaluator;
             private Runnable mEvaluator;

             TestView(Context context) {
                 super(context);
                 setWindowInsetsAnimationCallback(mInsetsCallback);
                 mContentPaint.setColor(APP_COLOR);
                 mContentPaint.setStyle(Paint.Style.FILL);
                 setWillNotDraw(false);
                 mRunEvaluator = () -> {
                     if (mEvaluator != null) {
                         mEvaluator.run();
                     }
                 };
             }

             @Override
             public WindowInsets onApplyWindowInsets(WindowInsets insets) {
                 mLayoutInsets = insets;
                 return WindowInsets.CONSUMED;
             }

             private WindowInsets getEffectiveInsets() {
                 return mAnimationInsets != null ? mAnimationInsets : mLayoutInsets;
             }

             @Override
             protected void onDraw(Canvas canvas) {
                 canvas.drawColor(BEHIND_IME_COLOR);
                 mTmpRect.set(0, 0, getWidth(), getHeight());
                 Insets insets = getEffectiveInsets().getInsets(ime());
                 insetRect(mTmpRect, insets);
                 canvas.drawRect(mTmpRect, mContentPaint);
                 removeCallbacks(mRunEvaluator);
                 post(mRunEvaluator);
             }

             private static boolean isImeAnimation(WindowInsetsAnimation animation) {
                 return (animation.getTypeMask() & ime()) != 0;
             }

             private static void insetRect(Rect rect, Insets insets) {
                 rect.left += insets.left;
                 rect.top += insets.top;
                 rect.right -= insets.right;
                 rect.bottom -= insets.bottom;
             }
         }
     }

     private static class ImeSession implements AutoCloseable {

         private static final long TIMEOUT = 2000;
         private final ComponentName mImeName;
         private Context mContext = InstrumentationRegistry.getInstrumentation().getContext();

         ImeSession(ComponentName ime) throws Exception {
             mImeName = ime;
             executeShellCommand("ime reset");
             executeShellCommand("ime enable " + ime.flattenToShortString());
             executeShellCommand("ime set " + ime.flattenToShortString());
             PollingCheck.check("Make sure that MockIME becomes available", TIMEOUT,
                     () -> ime.equals(getCurrentInputMethodId()));
         }

         @Override
         public void close() throws Exception {
             executeShellCommand("ime reset");
             PollingCheck.check("Make sure that MockIME becomes unavailable", TIMEOUT, () ->
                     mContext.getSystemService(InputMethodManager.class)
                             .getEnabledInputMethodList()
                             .stream()
                             .noneMatch(info -> mImeName.equals(info.getComponent())));
         }

         @Nullable
         private ComponentName getCurrentInputMethodId() {
             // TODO: Replace this with IMM#getCurrentInputMethodIdForTesting()
             return ComponentName.unflattenFromString(
                     Settings.Secure.getString(mContext.getContentResolver(),
                     Settings.Secure.DEFAULT_INPUT_METHOD));
         }
     }

     public static class SimpleIme extends InputMethodService {

         public static final int HEIGHT_DP = 200;
         public static final int SIDE_PADDING_DP = 50;

         @Override
         public View onCreateInputView() {
             final ViewGroup view = new FrameLayout(this);
             final View inner = new View(this);
             final float density = getResources().getDisplayMetrics().density;
             final int height = (int) (HEIGHT_DP * density);
             final int sidePadding = (int) (SIDE_PADDING_DP * density);
             view.setPadding(sidePadding, 0, sidePadding, 0);
             view.addView(inner, new FrameLayout.LayoutParams(MATCH_PARENT,
                     height));
             inner.setBackgroundColor(IME_COLOR);
             return view;
         }

         static ComponentName getName(Context context) {
             return new ComponentName(context, SimpleIme.class);
         }
     }
 }
	/*
	* Copyright (C) 2020 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.server.wm;

	import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
	import static android.app.WindowConfiguration.WINDOWING_MODE_UNDEFINED;
	import static android.content.Intent.FLAG_ACTIVITY_NEW_TASK;
	import static android.server.wm.ActivityManagerTestBase.executeShellCommand;
	import static android.server.wm.WindowInsetsAnimationUtils.requestControlThenTransitionToVisibility;
	import static android.view.Display.DEFAULT_DISPLAY;
	import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
	import static android.view.WindowInsets.Type.ime;
	import static android.view.WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN;

	import static androidx.test.platform.app.InstrumentationRegistry.getInstrumentation;

	import android.app.Activity;
	import android.app.ActivityOptions;
	import android.content.ComponentName;
	import android.content.Context;
	import android.content.Intent;
	import android.graphics.Bitmap;
	import android.graphics.Canvas;
	import android.graphics.Insets;
	import android.graphics.Paint;
	import android.graphics.Rect;
	import android.inputmethodservice.InputMethodService;
	import android.os.Bundle;
	import android.platform.test.annotations.LargeTest;
	import android.provider.Settings;
	import android.server.wm.WindowInsetsAnimationControllerTests.LimitedErrorCollector;
	import android.view.View;
	import android.view.ViewGroup;
	import android.view.Window;
	import android.view.WindowInsets;
	import android.view.WindowInsetsAnimation;
	import android.view.WindowInsetsAnimation.Callback;
	import android.view.WindowInsetsController;
	import android.view.inputmethod.EditorInfo;
	import android.view.inputmethod.InputMethodManager;
	import android.widget.EditText;
	import android.widget.FrameLayout;

	import androidx.annotation.NonNull;
	import androidx.annotation.Nullable;
	import androidx.test.platform.app.InstrumentationRegistry;
	import androidx.test.rule.ActivityTestRule;

	import com.android.compatibility.common.util.PollingCheck;
	import com.android.compatibility.common.util.SystemUtil;

	import org.junit.Rule;
	import org.junit.Test;

	import java.lang.reflect.Array;
	import java.util.List;
	import java.util.Locale;
	import java.util.function.Supplier;

	@LargeTest
	public class WindowInsetsAnimationSynchronicityTests {
	private static final int APP_COLOR = 0xff01fe10; // green
	private static final int BEHIND_IME_COLOR = 0xfffeef00; // yellow
	private static final int IME_COLOR = 0xfffe01fd; // pink

	@Rule
	public LimitedErrorCollector mErrorCollector = new LimitedErrorCollector();

	private final Context mContext = InstrumentationRegistry.getInstrumentation().getContext();

	@Test
	public void testShowAndHide_renderSynchronouslyBetweenImeWindowAndAppContent() throws Throwable {
	runTest(false /* useControlApi */);
	}

	@Test
	public void testControl_rendersSynchronouslyBetweenImeWindowAndAppContent() throws Throwable {
	runTest(true /* useControlApi */);
	}

	private void runTest(boolean useControlApi) throws Exception {
	try (ImeSession imeSession = new ImeSession(SimpleIme.getName(mContext))) {
	TestActivity activity = launchActivity();
	activity.setUseControlApi(useControlApi);
	PollingCheck.waitFor(activity::hasWindowFocus);
	activity.setEvaluator(() -> {
	// This runs from time to time on the UI thread.
	Bitmap screenshot = getInstrumentation().getUiAutomation().takeScreenshot();
	final int center = screenshot.getWidth() / 2;
	int imePositionApp = lowestPixelWithColor(APP_COLOR, 1, screenshot);
	int contentBottomMiddle = lowestPixelWithColor(APP_COLOR, center, screenshot);
	int behindImeBottomMiddle =
	lowestPixelWithColor(BEHIND_IME_COLOR, center, screenshot);
	int imePositionIme = Math.max(contentBottomMiddle, behindImeBottomMiddle);
	if (imePositionApp != imePositionIme) {
	mErrorCollector.addError(new AssertionError(String.format(Locale.US,
	"IME is positioned at %d (max of %d, %d),"
	+ " app thinks it is positioned at %d",
	imePositionIme, contentBottomMiddle, behindImeBottomMiddle,
	imePositionApp)));
	}
	});
	Thread.sleep(2000);
	activity.setEvaluator(null);
	}
	}

	private TestActivity launchActivity() {
	final ActivityOptions options= ActivityOptions.makeBasic();
	options.setLaunchWindowingMode(WINDOWING_MODE_FULLSCREEN);
	final TestActivity[] activity = (TestActivity[]) Array.newInstance(TestActivity.class, 1);
	SystemUtil.runWithShellPermissionIdentity(() -> {
	activity[0] = (TestActivity) getInstrumentation().startActivitySync(
	new Intent(getInstrumentation().getTargetContext(), TestActivity.class)
	.addFlags(FLAG_ACTIVITY_NEW_TASK), options.toBundle());
	});
	return activity[0];
	}

	private static int lowestPixelWithColor(int color, int x, Bitmap bitmap) {
	int[] pixels = new int[bitmap.getHeight()];
	bitmap.getPixels(pixels, 0, 1, x, 0, 1, bitmap.getHeight());
	for (int y = pixels.length - 1; y >= 0; y--) {
	if (pixels[y] == color) {
	return y;
	}
	}
	return -1;
	}

	public static class TestActivity extends Activity implements
	WindowInsetsController.OnControllableInsetsChangedListener {

	private TestView mTestView;
	private EditText mEditText;
	private Runnable mEvaluator;
	private boolean mUseControlApi;

	@Override
	protected void onCreate(@Nullable Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);
	getWindow().requestFeature(Window.FEATURE_NO_TITLE);
	getWindow().setDecorFitsSystemWindows(false);
	getWindow().setSoftInputMode(SOFT_INPUT_STATE_ALWAYS_HIDDEN);
	mTestView = new TestView(this);
	mEditText = new EditText(this);
	mEditText.setImeOptions(EditorInfo.IME_FLAG_NO_FULLSCREEN);
	mTestView.addView(mEditText);
	mTestView.mEvaluator = () -> {
	if (mEvaluator != null) {
	mEvaluator.run();
	}
	};
	mEditText.requestFocus();
	setContentView(mTestView);
	mEditText.getWindowInsetsController().addOnControllableInsetsChangedListener(this);
	}

	void setEvaluator(Runnable evaluator) {
	mEvaluator = evaluator;
	}

	void setUseControlApi(boolean useControlApi) {
	mUseControlApi = useControlApi;
	}

	@Override
	public void onControllableInsetsChanged(@NonNull WindowInsetsController controller,
	int typeMask) {
	if ((typeMask & ime()) != 0) {
	mEditText.getWindowInsetsController().removeOnControllableInsetsChangedListener(
	this);
	showIme();
	}
	}

	private void showIme() {
	if (mUseControlApi) {
	requestControlThenTransitionToVisibility(mTestView.getWindowInsetsController(),
	ime(), true);
	} else {
	mTestView.getWindowInsetsController().show(ime());
	}
	}

	private void hideIme() {
	if (mUseControlApi) {
	requestControlThenTransitionToVisibility(mTestView.getWindowInsetsController(),
	ime(), false);
	} else {
	mTestView.getWindowInsetsController().hide(ime());
	}
	}

	private static class TestView extends FrameLayout {
	private WindowInsets mLayoutInsets;
	private WindowInsets mAnimationInsets;
	private final Rect mTmpRect = new Rect();
	private final Paint mContentPaint = new Paint();

	private final Callback mInsetsCallback = new Callback(Callback.DISPATCH_MODE_STOP) {
	@NonNull
	@Override
	public WindowInsets onProgress(@NonNull WindowInsets insets,
	@NonNull List<WindowInsetsAnimation> runningAnimations) {
	if (runningAnimations.stream().anyMatch(TestView::isImeAnimation)) {
	mAnimationInsets = insets;
	invalidate();
	}
	return WindowInsets.CONSUMED;
	}

	@Override
	public void onEnd(@NonNull WindowInsetsAnimation animation) {
	if (isImeAnimation(animation)) {
	mAnimationInsets = null;
	post(() -> {
	if (mLayoutInsets.isVisible(ime())) {
	((TestActivity) getContext()).hideIme();
	} else {
	((TestActivity) getContext()).showIme();
	}
	});

	}
	}
	};
	private final Runnable mRunEvaluator;
	private Runnable mEvaluator;

	TestView(Context context) {
	super(context);
	setWindowInsetsAnimationCallback(mInsetsCallback);
	mContentPaint.setColor(APP_COLOR);
	mContentPaint.setStyle(Paint.Style.FILL);
	setWillNotDraw(false);
	mRunEvaluator = () -> {
	if (mEvaluator != null) {
	mEvaluator.run();
	}
	};
	}

	@Override
	public WindowInsets onApplyWindowInsets(WindowInsets insets) {
	mLayoutInsets = insets;
	return WindowInsets.CONSUMED;
	}

	private WindowInsets getEffectiveInsets() {
	return mAnimationInsets != null ? mAnimationInsets : mLayoutInsets;
	}

	@Override
	protected void onDraw(Canvas canvas) {
	canvas.drawColor(BEHIND_IME_COLOR);
	mTmpRect.set(0, 0, getWidth(), getHeight());
	Insets insets = getEffectiveInsets().getInsets(ime());
	insetRect(mTmpRect, insets);
	canvas.drawRect(mTmpRect, mContentPaint);
	removeCallbacks(mRunEvaluator);
	post(mRunEvaluator);
	}

	private static boolean isImeAnimation(WindowInsetsAnimation animation) {
	return (animation.getTypeMask() & ime()) != 0;
	}

	private static void insetRect(Rect rect, Insets insets) {
	rect.left += insets.left;
	rect.top += insets.top;
	rect.right -= insets.right;
	rect.bottom -= insets.bottom;
	}
	}
	}

	private static class ImeSession implements AutoCloseable {

	private static final long TIMEOUT = 2000;
	private final ComponentName mImeName;
	private Context mContext = InstrumentationRegistry.getInstrumentation().getContext();

	ImeSession(ComponentName ime) throws Exception {
	mImeName = ime;
	executeShellCommand("ime reset");
	executeShellCommand("ime enable " + ime.flattenToShortString());
	executeShellCommand("ime set " + ime.flattenToShortString());
	PollingCheck.check("Make sure that MockIME becomes available", TIMEOUT,
	() -> ime.equals(getCurrentInputMethodId()));
	}

	@Override
	public void close() throws Exception {
	executeShellCommand("ime reset");
	PollingCheck.check("Make sure that MockIME becomes unavailable", TIMEOUT, () ->
	mContext.getSystemService(InputMethodManager.class)
	.getEnabledInputMethodList()
	.stream()
	.noneMatch(info -> mImeName.equals(info.getComponent())));
	}

	@Nullable
	private ComponentName getCurrentInputMethodId() {
	// TODO: Replace this with IMM#getCurrentInputMethodIdForTesting()
	return ComponentName.unflattenFromString(
	Settings.Secure.getString(mContext.getContentResolver(),
	Settings.Secure.DEFAULT_INPUT_METHOD));
	}
	}

	public static class SimpleIme extends InputMethodService {

	public static final int HEIGHT_DP = 200;
	public static final int SIDE_PADDING_DP = 50;

	@Override
	public View onCreateInputView() {
	final ViewGroup view = new FrameLayout(this);
	final View inner = new View(this);
	final float density = getResources().getDisplayMetrics().density;
	final int height = (int) (HEIGHT_DP * density);
	final int sidePadding = (int) (SIDE_PADDING_DP * density);
	view.setPadding(sidePadding, 0, sidePadding, 0);
	view.addView(inner, new FrameLayout.LayoutParams(MATCH_PARENT,
	height));
	inner.setBackgroundColor(IME_COLOR);
	return view;
	}

	static ComponentName getName(Context context) {
	return new ComponentName(context, SimpleIme.class);
	}
	}
	}