| /* |
| * Copyright (C) 2008 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.widget.cts; |
| |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertFalse; |
| import static org.junit.Assert.assertNull; |
| import static org.junit.Assert.assertSame; |
| import static org.junit.Assert.assertTrue; |
| import static org.mockito.Matchers.anyInt; |
| import static org.mockito.Mockito.any; |
| import static org.mockito.Mockito.mock; |
| import static org.mockito.Mockito.never; |
| import static org.mockito.Mockito.times; |
| import static org.mockito.Mockito.verify; |
| import static org.mockito.Mockito.when; |
| |
| import android.app.Instrumentation; |
| import android.content.Context; |
| import android.content.pm.ActivityInfo; |
| import android.content.pm.PackageManager; |
| import android.content.res.Configuration; |
| import android.graphics.Color; |
| import android.graphics.Point; |
| import android.graphics.Rect; |
| import android.graphics.drawable.ColorDrawable; |
| import android.graphics.drawable.Drawable; |
| import android.os.SystemClock; |
| import android.support.test.InstrumentationRegistry; |
| import android.support.test.annotation.UiThreadTest; |
| import android.support.test.filters.FlakyTest; |
| import android.support.test.filters.SmallTest; |
| import android.support.test.rule.ActivityTestRule; |
| import android.support.test.runner.AndroidJUnit4; |
| import android.transition.Transition; |
| import android.transition.Transition.TransitionListener; |
| import android.transition.TransitionValues; |
| import android.util.AttributeSet; |
| import android.util.DisplayMetrics; |
| import android.view.Display; |
| import android.view.Gravity; |
| import android.view.MotionEvent; |
| import android.view.View; |
| import android.view.View.OnTouchListener; |
| import android.view.ViewGroup; |
| import android.view.ViewGroup.LayoutParams; |
| import android.view.WindowInsets; |
| import android.view.WindowManager; |
| import android.widget.ImageView; |
| import android.widget.PopupWindow; |
| import android.widget.PopupWindow.OnDismissListener; |
| import android.widget.TextView; |
| |
| import com.android.compatibility.common.util.WidgetTestUtils; |
| |
| import org.junit.Before; |
| import org.junit.Rule; |
| import org.junit.Test; |
| import org.junit.runner.RunWith; |
| |
| @FlakyTest |
| @SmallTest |
| @RunWith(AndroidJUnit4.class) |
| public class PopupWindowTest { |
| private static final int WINDOW_SIZE_DP = 50; |
| private static final int CONTENT_SIZE_DP = 30; |
| |
| private Instrumentation mInstrumentation; |
| private Context mContext; |
| private PopupWindowCtsActivity mActivity; |
| private PopupWindow mPopupWindow; |
| private TextView mTextView; |
| |
| @Rule |
| public ActivityTestRule<PopupWindowCtsActivity> mActivityRule = |
| new ActivityTestRule<>(PopupWindowCtsActivity.class); |
| |
| @Before |
| public void setup() { |
| mInstrumentation = InstrumentationRegistry.getInstrumentation(); |
| mContext = InstrumentationRegistry.getContext(); |
| mActivity = mActivityRule.getActivity(); |
| } |
| |
| @Test |
| public void testConstructor() { |
| new PopupWindow(mActivity); |
| |
| new PopupWindow(mActivity, null); |
| |
| new PopupWindow(mActivity, null, android.R.attr.popupWindowStyle); |
| |
| new PopupWindow(mActivity, null, 0, android.R.style.Widget_DeviceDefault_PopupWindow); |
| |
| new PopupWindow(mActivity, null, 0, android.R.style.Widget_DeviceDefault_Light_PopupWindow); |
| |
| new PopupWindow(mActivity, null, 0, android.R.style.Widget_Material_PopupWindow); |
| |
| new PopupWindow(mActivity, null, 0, android.R.style.Widget_Material_Light_PopupWindow); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testSize() { |
| mPopupWindow = new PopupWindow(); |
| assertEquals(0, mPopupWindow.getWidth()); |
| assertEquals(0, mPopupWindow.getHeight()); |
| |
| mPopupWindow = new PopupWindow(50, 50); |
| assertEquals(50, mPopupWindow.getWidth()); |
| assertEquals(50, mPopupWindow.getHeight()); |
| |
| mPopupWindow = new PopupWindow(-1, -1); |
| assertEquals(-1, mPopupWindow.getWidth()); |
| assertEquals(-1, mPopupWindow.getHeight()); |
| |
| TextView contentView = new TextView(mActivity); |
| mPopupWindow = new PopupWindow(contentView); |
| assertSame(contentView, mPopupWindow.getContentView()); |
| |
| mPopupWindow = new PopupWindow(contentView, 0, 0); |
| assertEquals(0, mPopupWindow.getWidth()); |
| assertEquals(0, mPopupWindow.getHeight()); |
| assertSame(contentView, mPopupWindow.getContentView()); |
| |
| mPopupWindow = new PopupWindow(contentView, 50, 50); |
| assertEquals(50, mPopupWindow.getWidth()); |
| assertEquals(50, mPopupWindow.getHeight()); |
| assertSame(contentView, mPopupWindow.getContentView()); |
| |
| mPopupWindow = new PopupWindow(contentView, -1, -1); |
| assertEquals(-1, mPopupWindow.getWidth()); |
| assertEquals(-1, mPopupWindow.getHeight()); |
| assertSame(contentView, mPopupWindow.getContentView()); |
| |
| mPopupWindow = new PopupWindow(contentView, 0, 0, true); |
| assertEquals(0, mPopupWindow.getWidth()); |
| assertEquals(0, mPopupWindow.getHeight()); |
| assertSame(contentView, mPopupWindow.getContentView()); |
| assertTrue(mPopupWindow.isFocusable()); |
| |
| mPopupWindow = new PopupWindow(contentView, 50, 50, false); |
| assertEquals(50, mPopupWindow.getWidth()); |
| assertEquals(50, mPopupWindow.getHeight()); |
| assertSame(contentView, mPopupWindow.getContentView()); |
| assertFalse(mPopupWindow.isFocusable()); |
| |
| mPopupWindow = new PopupWindow(contentView, -1, -1, true); |
| assertEquals(-1, mPopupWindow.getWidth()); |
| assertEquals(-1, mPopupWindow.getHeight()); |
| assertSame(contentView, mPopupWindow.getContentView()); |
| assertTrue(mPopupWindow.isFocusable()); |
| } |
| |
| @Test |
| public void testAccessEnterExitTransitions() { |
| PopupWindow w = new PopupWindow(mActivity, null, 0, 0); |
| assertNull(w.getEnterTransition()); |
| assertNull(w.getExitTransition()); |
| |
| w = new PopupWindow(mActivity, null, 0, R.style.PopupWindow_NullTransitions); |
| assertNull(w.getEnterTransition()); |
| assertNull(w.getExitTransition()); |
| |
| w = new PopupWindow(mActivity, null, 0, R.style.PopupWindow_CustomTransitions); |
| assertTrue(w.getEnterTransition() instanceof CustomTransition); |
| assertTrue(w.getExitTransition() instanceof CustomTransition); |
| |
| Transition enterTransition = new CustomTransition(); |
| Transition exitTransition = new CustomTransition(); |
| w = new PopupWindow(mActivity, null, 0, 0); |
| w.setEnterTransition(enterTransition); |
| w.setExitTransition(exitTransition); |
| assertEquals(enterTransition, w.getEnterTransition()); |
| assertEquals(exitTransition, w.getExitTransition()); |
| |
| w.setEnterTransition(null); |
| w.setExitTransition(null); |
| assertNull(w.getEnterTransition()); |
| assertNull(w.getExitTransition()); |
| } |
| |
| public static class CustomTransition extends Transition { |
| public CustomTransition() { |
| } |
| |
| // This constructor is needed for reflection-based creation of a transition when |
| // the transition is defined in layout XML via attribute. |
| @SuppressWarnings("unused") |
| public CustomTransition(Context context, AttributeSet attrs) { |
| super(context, attrs); |
| } |
| |
| @Override |
| public void captureStartValues(TransitionValues transitionValues) {} |
| |
| @Override |
| public void captureEndValues(TransitionValues transitionValues) {} |
| } |
| |
| @Test |
| public void testAccessBackground() { |
| mPopupWindow = new PopupWindow(mActivity); |
| |
| Drawable drawable = new ColorDrawable(); |
| mPopupWindow.setBackgroundDrawable(drawable); |
| assertSame(drawable, mPopupWindow.getBackground()); |
| |
| mPopupWindow.setBackgroundDrawable(null); |
| assertNull(mPopupWindow.getBackground()); |
| } |
| |
| @Test |
| public void testAccessAnimationStyle() { |
| mPopupWindow = new PopupWindow(mActivity); |
| // default is -1 |
| assertEquals(-1, mPopupWindow.getAnimationStyle()); |
| |
| mPopupWindow.setAnimationStyle(android.R.style.Animation_Toast); |
| assertEquals(android.R.style.Animation_Toast, |
| mPopupWindow.getAnimationStyle()); |
| |
| // abnormal values |
| mPopupWindow.setAnimationStyle(-100); |
| assertEquals(-100, mPopupWindow.getAnimationStyle()); |
| } |
| |
| @Test |
| public void testAccessContentView() throws Throwable { |
| mPopupWindow = new PopupWindow(mActivity); |
| assertNull(mPopupWindow.getContentView()); |
| |
| mActivityRule.runOnUiThread(() -> mTextView = new TextView(mActivity)); |
| mInstrumentation.waitForIdleSync(); |
| mPopupWindow.setContentView(mTextView); |
| assertSame(mTextView, mPopupWindow.getContentView()); |
| |
| mPopupWindow.setContentView(null); |
| assertNull(mPopupWindow.getContentView()); |
| |
| // can not set the content if the old content is shown |
| mPopupWindow.setContentView(mTextView); |
| assertFalse(mPopupWindow.isShowing()); |
| showPopup(); |
| ImageView img = new ImageView(mActivity); |
| assertTrue(mPopupWindow.isShowing()); |
| mPopupWindow.setContentView(img); |
| assertSame(mTextView, mPopupWindow.getContentView()); |
| dismissPopup(); |
| } |
| |
| @Test |
| public void testAccessFocusable() { |
| mPopupWindow = new PopupWindow(mActivity); |
| assertFalse(mPopupWindow.isFocusable()); |
| |
| mPopupWindow.setFocusable(true); |
| assertTrue(mPopupWindow.isFocusable()); |
| |
| mPopupWindow.setFocusable(false); |
| assertFalse(mPopupWindow.isFocusable()); |
| } |
| |
| @Test |
| public void testAccessHeight() { |
| mPopupWindow = new PopupWindow(mActivity); |
| assertEquals(WindowManager.LayoutParams.WRAP_CONTENT, mPopupWindow.getHeight()); |
| |
| int height = getDisplay().getHeight() / 2; |
| mPopupWindow.setHeight(height); |
| assertEquals(height, mPopupWindow.getHeight()); |
| |
| height = getDisplay().getHeight(); |
| mPopupWindow.setHeight(height); |
| assertEquals(height, mPopupWindow.getHeight()); |
| |
| mPopupWindow.setHeight(0); |
| assertEquals(0, mPopupWindow.getHeight()); |
| |
| height = getDisplay().getHeight() * 2; |
| mPopupWindow.setHeight(height); |
| assertEquals(height, mPopupWindow.getHeight()); |
| |
| height = -getDisplay().getHeight() / 2; |
| mPopupWindow.setHeight(height); |
| assertEquals(height, mPopupWindow.getHeight()); |
| } |
| |
| /** |
| * Gets the display. |
| * |
| * @return the display |
| */ |
| private Display getDisplay() { |
| WindowManager wm = (WindowManager) mActivity.getSystemService(Context.WINDOW_SERVICE); |
| return wm.getDefaultDisplay(); |
| } |
| |
| @Test |
| public void testAccessWidth() { |
| mPopupWindow = new PopupWindow(mActivity); |
| assertEquals(WindowManager.LayoutParams.WRAP_CONTENT, mPopupWindow.getWidth()); |
| |
| int width = getDisplay().getWidth() / 2; |
| mPopupWindow.setWidth(width); |
| assertEquals(width, mPopupWindow.getWidth()); |
| |
| width = getDisplay().getWidth(); |
| mPopupWindow.setWidth(width); |
| assertEquals(width, mPopupWindow.getWidth()); |
| |
| mPopupWindow.setWidth(0); |
| assertEquals(0, mPopupWindow.getWidth()); |
| |
| width = getDisplay().getWidth() * 2; |
| mPopupWindow.setWidth(width); |
| assertEquals(width, mPopupWindow.getWidth()); |
| |
| width = - getDisplay().getWidth() / 2; |
| mPopupWindow.setWidth(width); |
| assertEquals(width, mPopupWindow.getWidth()); |
| } |
| |
| private static final int TOP = 0x00; |
| private static final int BOTTOM = 0x01; |
| |
| private static final int LEFT = 0x00; |
| private static final int RIGHT = 0x01; |
| |
| private static final int GREATER_THAN = 1; |
| private static final int LESS_THAN = -1; |
| private static final int EQUAL_TO = 0; |
| |
| @Test |
| public void testShowAsDropDown() throws Throwable { |
| final PopupWindow popup = createPopupWindow(createPopupContent(CONTENT_SIZE_DP, |
| CONTENT_SIZE_DP)); |
| popup.setClipToScreenEnabled(false); |
| popup.setOverlapAnchor(false); |
| popup.setAnimationStyle(0); |
| popup.setExitTransition(null); |
| popup.setEnterTransition(null); |
| |
| verifyPosition(popup, R.id.anchor_upper_left, |
| LEFT, EQUAL_TO, LEFT, TOP, EQUAL_TO, BOTTOM); |
| verifyPosition(popup, R.id.anchor_upper, |
| LEFT, EQUAL_TO, LEFT, TOP, EQUAL_TO, BOTTOM); |
| verifyPosition(popup, R.id.anchor_upper_right, |
| RIGHT, EQUAL_TO, RIGHT, TOP, EQUAL_TO, BOTTOM); |
| |
| verifyPosition(popup, R.id.anchor_middle_left, |
| LEFT, EQUAL_TO, LEFT, TOP, EQUAL_TO, BOTTOM); |
| verifyPosition(popup, R.id.anchor_middle, |
| LEFT, EQUAL_TO, LEFT, TOP, EQUAL_TO, BOTTOM); |
| verifyPosition(popup, R.id.anchor_middle_right, |
| RIGHT, EQUAL_TO, RIGHT, TOP, EQUAL_TO, BOTTOM); |
| |
| verifyPosition(popup, R.id.anchor_lower_left, |
| LEFT, EQUAL_TO, LEFT, BOTTOM, EQUAL_TO, TOP); |
| verifyPosition(popup, R.id.anchor_lower, |
| LEFT, EQUAL_TO, LEFT, BOTTOM, EQUAL_TO, TOP); |
| verifyPosition(popup, R.id.anchor_lower_right, |
| RIGHT, EQUAL_TO, RIGHT, BOTTOM, EQUAL_TO, TOP); |
| } |
| |
| @Test |
| public void testShowAsDropDown_ClipToScreen() throws Throwable { |
| final PopupWindow popup = createPopupWindow(createPopupContent(CONTENT_SIZE_DP, |
| CONTENT_SIZE_DP)); |
| popup.setClipToScreenEnabled(true); |
| popup.setOverlapAnchor(false); |
| popup.setAnimationStyle(0); |
| popup.setExitTransition(null); |
| popup.setEnterTransition(null); |
| |
| verifyPosition(popup, R.id.anchor_upper_left, |
| LEFT, EQUAL_TO, LEFT, TOP, EQUAL_TO, BOTTOM); |
| verifyPosition(popup, R.id.anchor_upper, |
| LEFT, EQUAL_TO, LEFT, TOP, EQUAL_TO, BOTTOM); |
| verifyPosition(popup, R.id.anchor_upper_right, |
| RIGHT, EQUAL_TO, RIGHT, TOP, EQUAL_TO, BOTTOM); |
| |
| verifyPosition(popup, R.id.anchor_middle_left, |
| LEFT, EQUAL_TO, LEFT, TOP, EQUAL_TO, BOTTOM); |
| verifyPosition(popup, R.id.anchor_middle, |
| LEFT, EQUAL_TO, LEFT, TOP, EQUAL_TO, BOTTOM); |
| verifyPosition(popup, R.id.anchor_middle_right, |
| RIGHT, EQUAL_TO, RIGHT, TOP, EQUAL_TO, BOTTOM); |
| |
| verifyPosition(popup, R.id.anchor_lower_left, |
| LEFT, EQUAL_TO, LEFT, BOTTOM, EQUAL_TO, TOP); |
| verifyPosition(popup, R.id.anchor_lower, |
| LEFT, EQUAL_TO, LEFT, BOTTOM, EQUAL_TO, TOP); |
| verifyPosition(popup, R.id.anchor_lower_right, |
| RIGHT, EQUAL_TO, RIGHT, BOTTOM, EQUAL_TO, TOP); |
| } |
| |
| @Test |
| public void testShowAsDropDown_ClipToScreen_Overlap() throws Throwable { |
| final PopupWindow popup = createPopupWindow(createPopupContent(CONTENT_SIZE_DP, |
| CONTENT_SIZE_DP)); |
| popup.setClipToScreenEnabled(true); |
| popup.setOverlapAnchor(true); |
| popup.setAnimationStyle(0); |
| popup.setExitTransition(null); |
| popup.setEnterTransition(null); |
| |
| verifyPosition(popup, R.id.anchor_upper_left, |
| LEFT, EQUAL_TO, LEFT, TOP, EQUAL_TO, TOP); |
| verifyPosition(popup, R.id.anchor_upper, |
| LEFT, EQUAL_TO, LEFT, TOP, EQUAL_TO, TOP); |
| verifyPosition(popup, R.id.anchor_upper_right, |
| RIGHT, EQUAL_TO, RIGHT, TOP, EQUAL_TO, TOP); |
| |
| verifyPosition(popup, R.id.anchor_middle_left, |
| LEFT, EQUAL_TO, LEFT, TOP, EQUAL_TO, TOP); |
| verifyPosition(popup, R.id.anchor_middle, |
| LEFT, EQUAL_TO, LEFT, TOP, EQUAL_TO, TOP); |
| verifyPosition(popup, R.id.anchor_middle_right, |
| RIGHT, EQUAL_TO, RIGHT, TOP, EQUAL_TO, TOP); |
| |
| verifyPosition(popup, R.id.anchor_lower_left, |
| LEFT, EQUAL_TO, LEFT, BOTTOM, EQUAL_TO, TOP); |
| verifyPosition(popup, R.id.anchor_lower, |
| LEFT, EQUAL_TO, LEFT, BOTTOM, EQUAL_TO, TOP); |
| verifyPosition(popup, R.id.anchor_lower_right, |
| RIGHT, EQUAL_TO, RIGHT, BOTTOM, EQUAL_TO, TOP); |
| } |
| |
| @Test |
| public void testShowAsDropDown_ClipToScreen_Overlap_Offset() throws Throwable { |
| final PopupWindow popup = createPopupWindow(createPopupContent(CONTENT_SIZE_DP, |
| CONTENT_SIZE_DP)); |
| popup.setClipToScreenEnabled(true); |
| popup.setOverlapAnchor(true); |
| popup.setAnimationStyle(0); |
| popup.setExitTransition(null); |
| popup.setEnterTransition(null); |
| |
| final int offsetX = mActivity.findViewById(R.id.anchor_upper).getWidth() / 2; |
| final int offsetY = mActivity.findViewById(R.id.anchor_upper).getHeight() / 2; |
| final int gravity = Gravity.TOP | Gravity.START; |
| |
| verifyPosition(popup, R.id.anchor_upper_left, |
| LEFT, GREATER_THAN, LEFT, TOP, GREATER_THAN, TOP, |
| offsetX, offsetY, gravity); |
| verifyPosition(popup, R.id.anchor_upper, |
| LEFT, GREATER_THAN, LEFT, TOP, GREATER_THAN, TOP, |
| offsetX, offsetY, gravity); |
| verifyPosition(popup, R.id.anchor_upper_right, |
| RIGHT, EQUAL_TO, RIGHT, TOP, GREATER_THAN, TOP, |
| offsetX, offsetY, gravity); |
| |
| verifyPosition(popup, R.id.anchor_middle_left, |
| LEFT, GREATER_THAN, LEFT, TOP, GREATER_THAN, TOP, |
| offsetX, offsetY, gravity); |
| verifyPosition(popup, R.id.anchor_middle, |
| LEFT, GREATER_THAN, LEFT, TOP, GREATER_THAN, TOP, |
| offsetX, offsetY, gravity); |
| verifyPosition(popup, R.id.anchor_middle_right, |
| RIGHT, EQUAL_TO, RIGHT, TOP, GREATER_THAN, TOP, |
| offsetX, offsetY, gravity); |
| |
| verifyPosition(popup, R.id.anchor_lower_left, |
| LEFT, GREATER_THAN, LEFT, BOTTOM, LESS_THAN, BOTTOM, |
| offsetX, offsetY, gravity); |
| verifyPosition(popup, R.id.anchor_lower, |
| LEFT, GREATER_THAN, LEFT, BOTTOM, LESS_THAN, BOTTOM, |
| offsetX, offsetY, gravity); |
| verifyPosition(popup, R.id.anchor_lower_right, |
| RIGHT, EQUAL_TO, RIGHT, BOTTOM, LESS_THAN, BOTTOM, |
| offsetX, offsetY, gravity); |
| } |
| |
| @Test |
| public void testShowAsDropDown_ClipToScreen_TooBig() throws Throwable { |
| final View rootView = mActivity.findViewById(R.id.anchor_upper_left).getRootView(); |
| final int width = rootView.getWidth() * 2; |
| final int height = rootView.getHeight() * 2; |
| |
| final PopupWindow popup = createPopupWindow(createPopupContent(width, height)); |
| popup.setWidth(width); |
| popup.setHeight(height); |
| |
| popup.setClipToScreenEnabled(true); |
| popup.setOverlapAnchor(false); |
| popup.setAnimationStyle(0); |
| popup.setExitTransition(null); |
| popup.setEnterTransition(null); |
| |
| verifyPosition(popup, R.id.anchor_upper_left, |
| LEFT, EQUAL_TO, LEFT, TOP, LESS_THAN, TOP); |
| verifyPosition(popup, R.id.anchor_upper, |
| LEFT, LESS_THAN, LEFT, TOP, LESS_THAN, TOP); |
| verifyPosition(popup, R.id.anchor_upper_right, |
| RIGHT, EQUAL_TO, RIGHT, TOP, LESS_THAN, TOP); |
| |
| verifyPosition(popup, R.id.anchor_middle_left, |
| LEFT, EQUAL_TO, LEFT, TOP, LESS_THAN, TOP); |
| verifyPosition(popup, R.id.anchor_middle, |
| LEFT, LESS_THAN, LEFT, TOP, LESS_THAN, TOP); |
| verifyPosition(popup, R.id.anchor_middle_right, |
| RIGHT, EQUAL_TO, RIGHT, TOP, LESS_THAN, TOP); |
| |
| verifyPosition(popup, R.id.anchor_lower_left, |
| LEFT, EQUAL_TO, LEFT, BOTTOM, EQUAL_TO, BOTTOM); |
| verifyPosition(popup, R.id.anchor_lower, |
| LEFT, LESS_THAN, LEFT, BOTTOM, EQUAL_TO, BOTTOM); |
| verifyPosition(popup, R.id.anchor_lower_right, |
| RIGHT, EQUAL_TO, RIGHT, BOTTOM, EQUAL_TO, BOTTOM); |
| } |
| |
| private void verifyPosition(PopupWindow popup, int anchorId, |
| int contentEdgeX, int operatorX, int anchorEdgeX, |
| int contentEdgeY, int operatorY, int anchorEdgeY) throws Throwable { |
| verifyPosition(popup, mActivity.findViewById(anchorId), |
| contentEdgeX, operatorX, anchorEdgeX, |
| contentEdgeY, operatorY, anchorEdgeY, |
| 0, 0, Gravity.TOP | Gravity.START); |
| } |
| |
| private void verifyPosition(PopupWindow popup, int anchorId, |
| int contentEdgeX, int operatorX, int anchorEdgeX, |
| int contentEdgeY, int operatorY, int anchorEdgeY, |
| int offsetX, int offsetY, int gravity) throws Throwable { |
| verifyPosition(popup, mActivity.findViewById(anchorId), |
| contentEdgeX, operatorX, anchorEdgeX, |
| contentEdgeY, operatorY, anchorEdgeY, offsetX, offsetY, gravity); |
| } |
| |
| private void verifyPosition(PopupWindow popup, View anchor, |
| int contentEdgeX, int operatorX, int anchorEdgeX, |
| int contentEdgeY, int operatorY, int anchorEdgeY) throws Throwable { |
| verifyPosition(popup, anchor, |
| contentEdgeX, operatorX, anchorEdgeX, |
| contentEdgeY, operatorY, anchorEdgeY, |
| 0, 0, Gravity.TOP | Gravity.START); |
| } |
| |
| private void verifyPosition(PopupWindow popup, View anchor, |
| int contentEdgeX, int operatorX, int anchorEdgeX, |
| int contentEdgeY, int operatorY, int anchorEdgeY, |
| int offsetX, int offsetY, int gravity) throws Throwable { |
| final View content = popup.getContentView(); |
| |
| mActivityRule.runOnUiThread(() -> popup.showAsDropDown( |
| anchor, offsetX, offsetY, gravity)); |
| mInstrumentation.waitForIdleSync(); |
| |
| assertTrue(popup.isShowing()); |
| verifyPositionX(content, contentEdgeX, operatorX, anchor, anchorEdgeX); |
| verifyPositionY(content, contentEdgeY, operatorY, anchor, anchorEdgeY); |
| |
| // Make sure it fits in the display frame. |
| final Rect displayFrame = new Rect(); |
| anchor.getWindowVisibleDisplayFrame(displayFrame); |
| final Rect contentFrame = new Rect(); |
| content.getBoundsOnScreen(contentFrame); |
| assertTrue("Content (" + contentFrame + ") extends outside display (" |
| + displayFrame + ")", displayFrame.contains(contentFrame)); |
| |
| mActivityRule.runOnUiThread(popup::dismiss); |
| mInstrumentation.waitForIdleSync(); |
| |
| assertFalse(popup.isShowing()); |
| } |
| |
| private void verifyPositionY(View content, int contentEdge, int flags, |
| View anchor, int anchorEdge) { |
| final int[] anchorOnScreenXY = new int[2]; |
| anchor.getLocationOnScreen(anchorOnScreenXY); |
| int anchorY = anchorOnScreenXY[1]; |
| if ((anchorEdge & BOTTOM) == BOTTOM) { |
| anchorY += anchor.getHeight(); |
| } |
| |
| final int[] contentOnScreenXY = new int[2]; |
| content.getLocationOnScreen(contentOnScreenXY); |
| int contentY = contentOnScreenXY[1]; |
| if ((contentEdge & BOTTOM) == BOTTOM) { |
| contentY += content.getHeight(); |
| } |
| |
| assertComparison(contentY, flags, anchorY); |
| } |
| |
| private void verifyPositionX(View content, int contentEdge, int flags, |
| View anchor, int anchorEdge) { |
| final int[] anchorOnScreenXY = new int[2]; |
| anchor.getLocationOnScreen(anchorOnScreenXY); |
| int anchorX = anchorOnScreenXY[0]; |
| if ((anchorEdge & RIGHT) == RIGHT) { |
| anchorX += anchor.getWidth(); |
| } |
| |
| final int[] contentOnScreenXY = new int[2]; |
| content.getLocationOnScreen(contentOnScreenXY); |
| int contentX = contentOnScreenXY[0]; |
| if ((contentEdge & RIGHT) == RIGHT) { |
| contentX += content.getWidth(); |
| } |
| |
| assertComparison(contentX, flags, anchorX); |
| } |
| |
| private void assertComparison(int left, int operator, int right) { |
| switch (operator) { |
| case GREATER_THAN: |
| assertTrue(left + " <= " + right, left > right); |
| break; |
| case LESS_THAN: |
| assertTrue(left + " >= " + right, left < right); |
| break; |
| case EQUAL_TO: |
| assertTrue(left + " != " + right, left == right); |
| break; |
| } |
| } |
| |
| @Test |
| public void testShowAtLocation() throws Throwable { |
| int[] popupContentViewInWindowXY = new int[2]; |
| int[] popupContentViewOnScreenXY = new int[2]; |
| Rect containingRect = new Rect(); |
| |
| mPopupWindow = createPopupWindow(createPopupContent(CONTENT_SIZE_DP, CONTENT_SIZE_DP)); |
| // Do not attach within the decor; we will be measuring location |
| // with regard to screen coordinates. |
| mPopupWindow.setAttachedInDecor(false); |
| assertFalse(mPopupWindow.isAttachedInDecor()); |
| |
| final View upperAnchor = mActivity.findViewById(R.id.anchor_upper); |
| final WindowInsets windowInsets = upperAnchor.getRootWindowInsets(); |
| final int xOff = windowInsets.getSystemWindowInsetLeft() + 10; |
| final int yOff = windowInsets.getSystemWindowInsetTop() + 21; |
| assertFalse(mPopupWindow.isShowing()); |
| mPopupWindow.getContentView().getLocationInWindow(popupContentViewInWindowXY); |
| assertEquals(0, popupContentViewInWindowXY[0]); |
| assertEquals(0, popupContentViewInWindowXY[1]); |
| |
| mActivityRule.runOnUiThread( |
| () -> mPopupWindow.showAtLocation(upperAnchor, Gravity.NO_GRAVITY, xOff, yOff)); |
| mInstrumentation.waitForIdleSync(); |
| |
| assertTrue(mPopupWindow.isShowing()); |
| mPopupWindow.getContentView().getLocationInWindow(popupContentViewInWindowXY); |
| mPopupWindow.getContentView().getLocationOnScreen(popupContentViewOnScreenXY); |
| upperAnchor.getWindowDisplayFrame(containingRect); |
| |
| assertTrue(popupContentViewInWindowXY[0] >= 0); |
| assertTrue(popupContentViewInWindowXY[1] >= 0); |
| assertEquals(containingRect.left + popupContentViewInWindowXY[0] + xOff, popupContentViewOnScreenXY[0]); |
| assertEquals(containingRect.top + popupContentViewInWindowXY[1] + yOff, popupContentViewOnScreenXY[1]); |
| |
| dismissPopup(); |
| } |
| |
| @Test |
| public void testShowAsDropDownWithOffsets() throws Throwable { |
| int[] anchorXY = new int[2]; |
| int[] viewOnScreenXY = new int[2]; |
| int[] viewInWindowXY = new int[2]; |
| |
| mPopupWindow = createPopupWindow(createPopupContent(CONTENT_SIZE_DP, CONTENT_SIZE_DP)); |
| final View upperAnchor = mActivity.findViewById(R.id.anchor_upper); |
| upperAnchor.getLocationOnScreen(anchorXY); |
| int height = upperAnchor.getHeight(); |
| |
| final int xOff = 11; |
| final int yOff = 12; |
| |
| mActivityRule.runOnUiThread(() -> mPopupWindow.showAsDropDown(upperAnchor, xOff, yOff)); |
| mInstrumentation.waitForIdleSync(); |
| |
| mPopupWindow.getContentView().getLocationOnScreen(viewOnScreenXY); |
| mPopupWindow.getContentView().getLocationInWindow(viewInWindowXY); |
| assertEquals(anchorXY[0] + xOff + viewInWindowXY[0], viewOnScreenXY[0]); |
| assertEquals(anchorXY[1] + height + yOff + viewInWindowXY[1], viewOnScreenXY[1]); |
| |
| dismissPopup(); |
| } |
| |
| @Test |
| public void testOverlapAnchor() throws Throwable { |
| int[] anchorXY = new int[2]; |
| int[] viewOnScreenXY = new int[2]; |
| int[] viewInWindowXY = new int[2]; |
| |
| mPopupWindow = createPopupWindow(createPopupContent(CONTENT_SIZE_DP, CONTENT_SIZE_DP)); |
| final View upperAnchor = mActivity.findViewById(R.id.anchor_upper); |
| upperAnchor.getLocationOnScreen(anchorXY); |
| |
| assertFalse(mPopupWindow.getOverlapAnchor()); |
| mPopupWindow.setOverlapAnchor(true); |
| assertTrue(mPopupWindow.getOverlapAnchor()); |
| |
| mActivityRule.runOnUiThread(() -> mPopupWindow.showAsDropDown(upperAnchor, 0, 0)); |
| mInstrumentation.waitForIdleSync(); |
| |
| mPopupWindow.getContentView().getLocationOnScreen(viewOnScreenXY); |
| mPopupWindow.getContentView().getLocationInWindow(viewInWindowXY); |
| assertEquals(anchorXY[0] + viewInWindowXY[0], viewOnScreenXY[0]); |
| assertEquals(anchorXY[1] + viewInWindowXY[1], viewOnScreenXY[1]); |
| } |
| |
| @Test |
| public void testAccessWindowLayoutType() { |
| mPopupWindow = createPopupWindow(createPopupContent(CONTENT_SIZE_DP, CONTENT_SIZE_DP)); |
| assertEquals(WindowManager.LayoutParams.TYPE_APPLICATION_PANEL, |
| mPopupWindow.getWindowLayoutType()); |
| mPopupWindow.setWindowLayoutType(WindowManager.LayoutParams.TYPE_APPLICATION_SUB_PANEL); |
| assertEquals(WindowManager.LayoutParams.TYPE_APPLICATION_SUB_PANEL, |
| mPopupWindow.getWindowLayoutType()); |
| } |
| |
| @Test |
| public void testGetMaxAvailableHeight() { |
| mPopupWindow = createPopupWindow(createPopupContent(CONTENT_SIZE_DP, CONTENT_SIZE_DP)); |
| Rect displayFrame = new Rect(); |
| View anchorView = mActivity.findViewById(R.id.anchor_upper); |
| anchorView.getWindowVisibleDisplayFrame(displayFrame); |
| int displayHeight = displayFrame.height(); |
| int available = displayHeight - anchorView.getHeight(); |
| int maxAvailableHeight = mPopupWindow.getMaxAvailableHeight(anchorView); |
| int maxAvailableHeightIgnoringBottomDecoration = |
| mPopupWindow.getMaxAvailableHeight(anchorView, 0, true); |
| assertTrue(maxAvailableHeight > 0); |
| assertTrue(maxAvailableHeight <= available); |
| assertTrue(maxAvailableHeightIgnoringBottomDecoration >= maxAvailableHeight); |
| assertTrue(maxAvailableHeightIgnoringBottomDecoration <= available); |
| |
| int maxAvailableHeightWithOffset = mPopupWindow.getMaxAvailableHeight(anchorView, 2); |
| assertEquals(maxAvailableHeight - 2, maxAvailableHeightWithOffset); |
| |
| maxAvailableHeightWithOffset = |
| mPopupWindow.getMaxAvailableHeight(anchorView, maxAvailableHeight); |
| assertTrue(maxAvailableHeightWithOffset > 0); |
| assertTrue(maxAvailableHeightWithOffset <= available); |
| |
| maxAvailableHeightWithOffset = |
| mPopupWindow.getMaxAvailableHeight(anchorView, maxAvailableHeight / 2 - 1); |
| assertTrue(maxAvailableHeightWithOffset > 0); |
| assertTrue(maxAvailableHeightWithOffset <= available); |
| |
| maxAvailableHeightWithOffset = mPopupWindow.getMaxAvailableHeight(anchorView, -1); |
| assertTrue(maxAvailableHeightWithOffset > 0); |
| assertTrue(maxAvailableHeightWithOffset <= available); |
| |
| int maxAvailableHeightWithOffsetIgnoringBottomDecoration = |
| mPopupWindow.getMaxAvailableHeight(anchorView, 2, true); |
| assertEquals(maxAvailableHeightIgnoringBottomDecoration - 2, |
| maxAvailableHeightWithOffsetIgnoringBottomDecoration); |
| |
| maxAvailableHeightWithOffsetIgnoringBottomDecoration = |
| mPopupWindow.getMaxAvailableHeight(anchorView, maxAvailableHeight, true); |
| assertTrue(maxAvailableHeightWithOffsetIgnoringBottomDecoration > 0); |
| assertTrue(maxAvailableHeightWithOffsetIgnoringBottomDecoration <= available); |
| |
| maxAvailableHeightWithOffsetIgnoringBottomDecoration = |
| mPopupWindow.getMaxAvailableHeight(anchorView, maxAvailableHeight / 2 - 1, true); |
| assertTrue(maxAvailableHeightWithOffsetIgnoringBottomDecoration > 0); |
| assertTrue(maxAvailableHeightWithOffsetIgnoringBottomDecoration <= available); |
| |
| maxAvailableHeightWithOffsetIgnoringBottomDecoration = |
| mPopupWindow.getMaxAvailableHeight(anchorView, -1, true); |
| assertTrue(maxAvailableHeightWithOffsetIgnoringBottomDecoration > 0); |
| assertTrue(maxAvailableHeightWithOffsetIgnoringBottomDecoration <= available); |
| |
| anchorView = mActivity.findViewById(R.id.anchor_lower); |
| // On some devices the view might actually have larger size than the physical display |
| // due to chin and content will be laid out as if outside of the display. We need to use |
| // larger from the display height and the main view height. |
| available = Math.max(displayHeight, |
| mActivity.findViewById(android.R.id.content).getHeight()) - anchorView.getHeight(); |
| maxAvailableHeight = mPopupWindow.getMaxAvailableHeight(anchorView); |
| assertTrue(maxAvailableHeight > 0); |
| assertTrue(maxAvailableHeight <= available); |
| |
| anchorView = mActivity.findViewById(R.id.anchor_middle_left); |
| available = displayHeight - anchorView.getHeight() |
| - mActivity.findViewById(R.id.anchor_upper).getHeight(); |
| maxAvailableHeight = mPopupWindow.getMaxAvailableHeight(anchorView); |
| assertTrue(maxAvailableHeight > 0); |
| assertTrue(maxAvailableHeight <= available); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testDismiss() { |
| mPopupWindow = createPopupWindow(createPopupContent(CONTENT_SIZE_DP, CONTENT_SIZE_DP)); |
| assertFalse(mPopupWindow.isShowing()); |
| View anchorView = mActivity.findViewById(R.id.anchor_upper); |
| mPopupWindow.showAsDropDown(anchorView); |
| |
| mPopupWindow.dismiss(); |
| assertFalse(mPopupWindow.isShowing()); |
| |
| mPopupWindow.dismiss(); |
| assertFalse(mPopupWindow.isShowing()); |
| } |
| |
| @Test |
| public void testSetOnDismissListener() throws Throwable { |
| mActivityRule.runOnUiThread(() -> mTextView = new TextView(mActivity)); |
| mInstrumentation.waitForIdleSync(); |
| mPopupWindow = new PopupWindow(mTextView); |
| mPopupWindow.setOnDismissListener(null); |
| |
| OnDismissListener onDismissListener = mock(OnDismissListener.class); |
| mPopupWindow.setOnDismissListener(onDismissListener); |
| showPopup(); |
| dismissPopup(); |
| verify(onDismissListener, times(1)).onDismiss(); |
| |
| showPopup(); |
| dismissPopup(); |
| verify(onDismissListener, times(2)).onDismiss(); |
| |
| mPopupWindow.setOnDismissListener(null); |
| showPopup(); |
| dismissPopup(); |
| verify(onDismissListener, times(2)).onDismiss(); |
| } |
| |
| @Test |
| public void testUpdate() throws Throwable { |
| mPopupWindow = createPopupWindow(createPopupContent(CONTENT_SIZE_DP, CONTENT_SIZE_DP)); |
| mPopupWindow.setBackgroundDrawable(null); |
| showPopup(); |
| |
| mPopupWindow.setIgnoreCheekPress(); |
| mPopupWindow.setFocusable(true); |
| mPopupWindow.setTouchable(false); |
| mPopupWindow.setInputMethodMode(PopupWindow.INPUT_METHOD_NOT_NEEDED); |
| mPopupWindow.setClippingEnabled(false); |
| mPopupWindow.setOutsideTouchable(true); |
| |
| WindowManager.LayoutParams p = (WindowManager.LayoutParams) |
| mPopupWindow.getContentView().getRootView().getLayoutParams(); |
| |
| assertEquals(0, WindowManager.LayoutParams.FLAG_IGNORE_CHEEK_PRESSES & p.flags); |
| assertEquals(WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE, |
| WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE & p.flags); |
| assertEquals(0, WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE & p.flags); |
| assertEquals(0, WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH & p.flags); |
| assertEquals(0, WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS & p.flags); |
| assertEquals(0, WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM & p.flags); |
| |
| mActivityRule.runOnUiThread(mPopupWindow::update); |
| mInstrumentation.waitForIdleSync(); |
| |
| assertEquals(WindowManager.LayoutParams.FLAG_IGNORE_CHEEK_PRESSES, |
| WindowManager.LayoutParams.FLAG_IGNORE_CHEEK_PRESSES & p.flags); |
| assertEquals(0, WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE & p.flags); |
| assertEquals(WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE, |
| WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE & p.flags); |
| assertEquals(WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH, |
| WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH & p.flags); |
| assertEquals(WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS, |
| WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS & p.flags); |
| assertEquals(WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM, |
| WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM & p.flags); |
| } |
| |
| @Test |
| public void testEnterExitInterruption() throws Throwable { |
| final View anchorView = mActivity.findViewById(R.id.anchor_upper); |
| verifyEnterExitTransition( |
| () -> mPopupWindow.showAsDropDown(anchorView, 0, 0), true); |
| } |
| |
| @Test |
| public void testEnterExitTransitionAsDropDown() throws Throwable { |
| final View anchorView = mActivity.findViewById(R.id.anchor_upper); |
| verifyEnterExitTransition( |
| () -> mPopupWindow.showAsDropDown(anchorView, 0, 0), false); |
| } |
| |
| @Test |
| public void testEnterExitTransitionAtLocation() throws Throwable { |
| final View anchorView = mActivity.findViewById(R.id.anchor_upper); |
| verifyEnterExitTransition( |
| () -> mPopupWindow.showAtLocation(anchorView, Gravity.BOTTOM, 0, 0), false); |
| } |
| |
| private void verifyEnterExitTransition(Runnable showRunnable, boolean showAgain) |
| throws Throwable { |
| TransitionListener enterListener = mock(TransitionListener.class); |
| Transition enterTransition = new BaseTransition(); |
| enterTransition.addListener(enterListener); |
| |
| TransitionListener exitListener = mock(TransitionListener.class); |
| Transition exitTransition = new BaseTransition(); |
| exitTransition.addListener(exitListener); |
| |
| OnDismissListener dismissListener = mock(OnDismissListener.class); |
| |
| mPopupWindow = createPopupWindow(createPopupContent(CONTENT_SIZE_DP, CONTENT_SIZE_DP)); |
| mPopupWindow.setEnterTransition(enterTransition); |
| mPopupWindow.setExitTransition(exitTransition); |
| mPopupWindow.setOnDismissListener(dismissListener); |
| |
| mActivityRule.runOnUiThread(showRunnable); |
| mInstrumentation.waitForIdleSync(); |
| verify(enterListener, times(1)).onTransitionStart(any(Transition.class)); |
| verify(exitListener, never()).onTransitionStart(any(Transition.class)); |
| verify(dismissListener, never()).onDismiss(); |
| |
| mActivityRule.runOnUiThread(mPopupWindow::dismiss); |
| |
| int times; |
| if (showAgain) { |
| // Interrupt dismiss by calling show again, then actually dismiss. |
| mActivityRule.runOnUiThread(showRunnable); |
| mInstrumentation.waitForIdleSync(); |
| mActivityRule.runOnUiThread(mPopupWindow::dismiss); |
| |
| times = 2; |
| } else { |
| times = 1; |
| } |
| |
| mInstrumentation.waitForIdleSync(); |
| verify(enterListener, times(times)).onTransitionStart(any(Transition.class)); |
| verify(exitListener, times(times)).onTransitionStart(any(Transition.class)); |
| verify(dismissListener, times(times)).onDismiss(); |
| } |
| |
| @Test |
| public void testUpdatePositionAndDimension() throws Throwable { |
| int[] fstXY = new int[2]; |
| int[] sndXY = new int[2]; |
| int[] viewInWindowXY = new int[2]; |
| Rect containingRect = new Rect(); |
| final Point popupPos = new Point(); |
| |
| mActivityRule.runOnUiThread(() -> { |
| mPopupWindow = createPopupWindow(createPopupContent(CONTENT_SIZE_DP, CONTENT_SIZE_DP)); |
| // Do not attach within the decor; we will be measuring location |
| // with regard to screen coordinates. |
| mPopupWindow.setAttachedInDecor(false); |
| }); |
| |
| mInstrumentation.waitForIdleSync(); |
| // Do not update if it is not shown |
| assertFalse(mPopupWindow.isShowing()); |
| assertFalse(mPopupWindow.isAttachedInDecor()); |
| assertEquals(WINDOW_SIZE_DP, mPopupWindow.getWidth()); |
| assertEquals(WINDOW_SIZE_DP, mPopupWindow.getHeight()); |
| |
| showPopup(); |
| mPopupWindow.getContentView().getLocationInWindow(viewInWindowXY); |
| final View containerView = mActivity.findViewById(R.id.main_container); |
| containerView.getWindowDisplayFrame(containingRect); |
| |
| // update if it is not shown |
| mActivityRule.runOnUiThread(() -> mPopupWindow.update(80, 80)); |
| |
| mInstrumentation.waitForIdleSync(); |
| assertTrue(mPopupWindow.isShowing()); |
| assertEquals(80, mPopupWindow.getWidth()); |
| assertEquals(80, mPopupWindow.getHeight()); |
| |
| final WindowInsets windowInsets = containerView.getRootWindowInsets(); |
| popupPos.set(windowInsets.getStableInsetLeft() + 20, windowInsets.getStableInsetTop() + 50); |
| |
| // update if it is not shown |
| mActivityRule.runOnUiThread(() -> mPopupWindow.update(popupPos.x, popupPos.y, 50, 50)); |
| |
| mInstrumentation.waitForIdleSync(); |
| assertTrue(mPopupWindow.isShowing()); |
| assertEquals(50, mPopupWindow.getWidth()); |
| assertEquals(50, mPopupWindow.getHeight()); |
| |
| mPopupWindow.getContentView().getLocationOnScreen(fstXY); |
| assertEquals(containingRect.left + popupPos.x + viewInWindowXY[0], fstXY[0]); |
| assertEquals(containingRect.top + popupPos.y + viewInWindowXY[1], fstXY[1]); |
| |
| popupPos.set(windowInsets.getStableInsetLeft() + 4, windowInsets.getStableInsetTop()); |
| |
| // ignore if width or height is -1 |
| mActivityRule.runOnUiThread( |
| () -> mPopupWindow.update(popupPos.x, popupPos.y, -1, -1, true)); |
| mInstrumentation.waitForIdleSync(); |
| |
| assertTrue(mPopupWindow.isShowing()); |
| assertEquals(50, mPopupWindow.getWidth()); |
| assertEquals(50, mPopupWindow.getHeight()); |
| |
| mPopupWindow.getContentView().getLocationOnScreen(sndXY); |
| assertEquals(containingRect.left + popupPos.x + viewInWindowXY[0], sndXY[0]); |
| assertEquals(containingRect.top + popupPos.y + viewInWindowXY[1], sndXY[1]); |
| |
| dismissPopup(); |
| } |
| |
| @Test |
| public void testUpdateDimensionAndAlignAnchorView() throws Throwable { |
| mActivityRule.runOnUiThread( |
| () -> mPopupWindow = createPopupWindow(createPopupContent(CONTENT_SIZE_DP, |
| CONTENT_SIZE_DP))); |
| mInstrumentation.waitForIdleSync(); |
| |
| final View anchorView = mActivity.findViewById(R.id.anchor_upper); |
| mPopupWindow.update(anchorView, 50, 50); |
| // Do not update if it is not shown |
| assertFalse(mPopupWindow.isShowing()); |
| assertEquals(WINDOW_SIZE_DP, mPopupWindow.getWidth()); |
| assertEquals(WINDOW_SIZE_DP, mPopupWindow.getHeight()); |
| |
| mActivityRule.runOnUiThread(() -> mPopupWindow.showAsDropDown(anchorView)); |
| mInstrumentation.waitForIdleSync(); |
| // update if it is shown |
| mActivityRule.runOnUiThread(() -> mPopupWindow.update(anchorView, 50, 50)); |
| mInstrumentation.waitForIdleSync(); |
| assertTrue(mPopupWindow.isShowing()); |
| assertEquals(50, mPopupWindow.getWidth()); |
| assertEquals(50, mPopupWindow.getHeight()); |
| |
| // ignore if width or height is -1 |
| mActivityRule.runOnUiThread(() -> mPopupWindow.update(anchorView, -1, -1)); |
| mInstrumentation.waitForIdleSync(); |
| assertTrue(mPopupWindow.isShowing()); |
| assertEquals(50, mPopupWindow.getWidth()); |
| assertEquals(50, mPopupWindow.getHeight()); |
| |
| mActivityRule.runOnUiThread(mPopupWindow::dismiss); |
| mInstrumentation.waitForIdleSync(); |
| } |
| |
| @Test |
| public void testUpdateDimensionAndAlignAnchorViewWithOffsets() throws Throwable { |
| int[] anchorXY = new int[2]; |
| int[] viewInWindowOff = new int[2]; |
| int[] viewXY = new int[2]; |
| |
| mPopupWindow = createPopupWindow(createPopupContent(CONTENT_SIZE_DP, CONTENT_SIZE_DP)); |
| final View anchorView = mActivity.findViewById(R.id.anchor_upper); |
| // Do not update if it is not shown |
| assertFalse(mPopupWindow.isShowing()); |
| assertEquals(WINDOW_SIZE_DP, mPopupWindow.getWidth()); |
| assertEquals(WINDOW_SIZE_DP, mPopupWindow.getHeight()); |
| |
| showPopup(); |
| anchorView.getLocationOnScreen(anchorXY); |
| mPopupWindow.getContentView().getLocationInWindow(viewInWindowOff); |
| |
| // update if it is not shown |
| mActivityRule.runOnUiThread(() -> mPopupWindow.update(anchorView, 20, 50, 50, 50)); |
| |
| mInstrumentation.waitForIdleSync(); |
| |
| assertTrue(mPopupWindow.isShowing()); |
| assertEquals(50, mPopupWindow.getWidth()); |
| assertEquals(50, mPopupWindow.getHeight()); |
| |
| mPopupWindow.getContentView().getLocationOnScreen(viewXY); |
| |
| // The popup should appear below and to right with an offset. |
| assertEquals(anchorXY[0] + 20 + viewInWindowOff[0], viewXY[0]); |
| assertEquals(anchorXY[1] + anchorView.getHeight() + 50 + viewInWindowOff[1], viewXY[1]); |
| |
| // ignore width and height but change location |
| mActivityRule.runOnUiThread(() -> mPopupWindow.update(anchorView, 10, 50, -1, -1)); |
| mInstrumentation.waitForIdleSync(); |
| |
| assertTrue(mPopupWindow.isShowing()); |
| assertEquals(50, mPopupWindow.getWidth()); |
| assertEquals(50, mPopupWindow.getHeight()); |
| |
| mPopupWindow.getContentView().getLocationOnScreen(viewXY); |
| |
| // The popup should appear below and to right with an offset. |
| assertEquals(anchorXY[0] + 10 + viewInWindowOff[0], viewXY[0]); |
| assertEquals(anchorXY[1] + anchorView.getHeight() + 50 + viewInWindowOff[1], viewXY[1]); |
| |
| final View anotherView = mActivity.findViewById(R.id.anchor_middle_left); |
| mActivityRule.runOnUiThread(() -> mPopupWindow.update(anotherView, 0, 0, 60, 60)); |
| mInstrumentation.waitForIdleSync(); |
| |
| assertTrue(mPopupWindow.isShowing()); |
| assertEquals(60, mPopupWindow.getWidth()); |
| assertEquals(60, mPopupWindow.getHeight()); |
| |
| int[] newXY = new int[2]; |
| anotherView.getLocationOnScreen(newXY); |
| mPopupWindow.getContentView().getLocationOnScreen(viewXY); |
| |
| // The popup should appear below and to the right. |
| assertEquals(newXY[0] + viewInWindowOff[0], viewXY[0]); |
| assertEquals(newXY[1] + anotherView.getHeight() + viewInWindowOff[1], viewXY[1]); |
| |
| dismissPopup(); |
| } |
| |
| @Test |
| public void testAccessInputMethodMode() { |
| mPopupWindow = new PopupWindow(mActivity); |
| assertEquals(0, mPopupWindow.getInputMethodMode()); |
| |
| mPopupWindow.setInputMethodMode(PopupWindow.INPUT_METHOD_FROM_FOCUSABLE); |
| assertEquals(PopupWindow.INPUT_METHOD_FROM_FOCUSABLE, mPopupWindow.getInputMethodMode()); |
| |
| mPopupWindow.setInputMethodMode(PopupWindow.INPUT_METHOD_NEEDED); |
| assertEquals(PopupWindow.INPUT_METHOD_NEEDED, mPopupWindow.getInputMethodMode()); |
| |
| mPopupWindow.setInputMethodMode(PopupWindow.INPUT_METHOD_NOT_NEEDED); |
| assertEquals(PopupWindow.INPUT_METHOD_NOT_NEEDED, mPopupWindow.getInputMethodMode()); |
| |
| mPopupWindow.setInputMethodMode(-1); |
| assertEquals(-1, mPopupWindow.getInputMethodMode()); |
| } |
| |
| @Test |
| public void testAccessClippingEnabled() { |
| mPopupWindow = new PopupWindow(mActivity); |
| assertTrue(mPopupWindow.isClippingEnabled()); |
| |
| mPopupWindow.setClippingEnabled(false); |
| assertFalse(mPopupWindow.isClippingEnabled()); |
| } |
| |
| @Test |
| public void testAccessOutsideTouchable() { |
| mPopupWindow = new PopupWindow(mActivity); |
| assertFalse(mPopupWindow.isOutsideTouchable()); |
| |
| mPopupWindow.setOutsideTouchable(true); |
| assertTrue(mPopupWindow.isOutsideTouchable()); |
| } |
| |
| @Test |
| public void testAccessTouchable() { |
| mPopupWindow = new PopupWindow(mActivity); |
| assertTrue(mPopupWindow.isTouchable()); |
| |
| mPopupWindow.setTouchable(false); |
| assertFalse(mPopupWindow.isTouchable()); |
| } |
| |
| @Test |
| public void testIsAboveAnchor() throws Throwable { |
| mActivityRule.runOnUiThread(() -> mPopupWindow = createPopupWindow(createPopupContent( |
| CONTENT_SIZE_DP, CONTENT_SIZE_DP))); |
| mInstrumentation.waitForIdleSync(); |
| final View upperAnchor = mActivity.findViewById(R.id.anchor_upper); |
| |
| mActivityRule.runOnUiThread(() -> mPopupWindow.showAsDropDown(upperAnchor)); |
| mInstrumentation.waitForIdleSync(); |
| assertFalse(mPopupWindow.isAboveAnchor()); |
| dismissPopup(); |
| |
| mPopupWindow = createPopupWindow(createPopupContent(CONTENT_SIZE_DP, CONTENT_SIZE_DP)); |
| final View lowerAnchor = mActivity.findViewById(R.id.anchor_lower); |
| |
| mActivityRule.runOnUiThread(() -> mPopupWindow.showAsDropDown(lowerAnchor, 0, 0)); |
| mInstrumentation.waitForIdleSync(); |
| assertTrue(mPopupWindow.isAboveAnchor()); |
| dismissPopup(); |
| } |
| |
| @Test |
| public void testSetTouchInterceptor() throws Throwable { |
| mActivityRule.runOnUiThread(() -> mTextView = new TextView(mActivity)); |
| mInstrumentation.waitForIdleSync(); |
| mPopupWindow = new PopupWindow(mTextView); |
| |
| OnTouchListener onTouchListener = mock(OnTouchListener.class); |
| when(onTouchListener.onTouch(any(View.class), any(MotionEvent.class))).thenReturn(true); |
| |
| mPopupWindow.setTouchInterceptor(onTouchListener); |
| mPopupWindow.setFocusable(true); |
| mPopupWindow.setOutsideTouchable(true); |
| Drawable drawable = new ColorDrawable(); |
| mPopupWindow.setBackgroundDrawable(drawable); |
| showPopup(); |
| |
| int[] xy = new int[2]; |
| mPopupWindow.getContentView().getLocationOnScreen(xy); |
| final int viewWidth = mPopupWindow.getContentView().getWidth(); |
| final int viewHeight = mPopupWindow.getContentView().getHeight(); |
| final float x = xy[0] + (viewWidth / 2.0f); |
| float y = xy[1] + (viewHeight / 2.0f); |
| |
| long downTime = SystemClock.uptimeMillis(); |
| long eventTime = SystemClock.uptimeMillis(); |
| MotionEvent event = MotionEvent.obtain(downTime, eventTime, |
| MotionEvent.ACTION_DOWN, x, y, 0); |
| mInstrumentation.sendPointerSync(event); |
| verify(onTouchListener, times(1)).onTouch(any(View.class), any(MotionEvent.class)); |
| |
| downTime = SystemClock.uptimeMillis(); |
| eventTime = SystemClock.uptimeMillis(); |
| event = MotionEvent.obtain(downTime, eventTime, MotionEvent.ACTION_UP, x, y, 0); |
| mInstrumentation.sendPointerSync(event); |
| verify(onTouchListener, times(2)).onTouch(any(View.class), any(MotionEvent.class)); |
| |
| mPopupWindow.setTouchInterceptor(null); |
| downTime = SystemClock.uptimeMillis(); |
| eventTime = SystemClock.uptimeMillis(); |
| event = MotionEvent.obtain(downTime, eventTime, MotionEvent.ACTION_DOWN, x, y, 0); |
| mInstrumentation.sendPointerSync(event); |
| verify(onTouchListener, times(2)).onTouch(any(View.class), any(MotionEvent.class)); |
| } |
| |
| @Test |
| public void testSetWindowLayoutMode() throws Throwable { |
| mActivityRule.runOnUiThread(() -> mTextView = new TextView(mActivity)); |
| mInstrumentation.waitForIdleSync(); |
| mPopupWindow = new PopupWindow(mTextView); |
| showPopup(); |
| |
| ViewGroup.LayoutParams p = mPopupWindow.getContentView().getRootView().getLayoutParams(); |
| assertEquals(0, p.width); |
| assertEquals(0, p.height); |
| |
| mPopupWindow.setWindowLayoutMode(LayoutParams.WRAP_CONTENT, LayoutParams.MATCH_PARENT); |
| mActivityRule.runOnUiThread(() -> mPopupWindow.update(20, 50, 50, 50)); |
| |
| assertEquals(LayoutParams.WRAP_CONTENT, p.width); |
| assertEquals(LayoutParams.MATCH_PARENT, p.height); |
| } |
| |
| @Test |
| public void testAccessElevation() throws Throwable { |
| mPopupWindow = createPopupWindow(createPopupContent(CONTENT_SIZE_DP, CONTENT_SIZE_DP)); |
| mActivityRule.runOnUiThread(() -> mPopupWindow.setElevation(2.0f)); |
| |
| showPopup(); |
| assertEquals(2.0f, mPopupWindow.getElevation(), 0.0f); |
| |
| dismissPopup(); |
| mActivityRule.runOnUiThread(() -> mPopupWindow.setElevation(4.0f)); |
| showPopup(); |
| assertEquals(4.0f, mPopupWindow.getElevation(), 0.0f); |
| |
| dismissPopup(); |
| mActivityRule.runOnUiThread(() -> mPopupWindow.setElevation(10.0f)); |
| showPopup(); |
| assertEquals(10.0f, mPopupWindow.getElevation(), 0.0f); |
| } |
| |
| @Test |
| public void testAccessSoftInputMode() throws Throwable { |
| mPopupWindow = createPopupWindow(createPopupContent(CONTENT_SIZE_DP, CONTENT_SIZE_DP)); |
| mActivityRule.runOnUiThread( |
| () -> mPopupWindow.setSoftInputMode( |
| WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE)); |
| |
| showPopup(); |
| assertEquals(WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE, |
| mPopupWindow.getSoftInputMode()); |
| |
| dismissPopup(); |
| mActivityRule.runOnUiThread( |
| () -> mPopupWindow.setSoftInputMode( |
| WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN)); |
| showPopup(); |
| assertEquals(WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN, |
| mPopupWindow.getSoftInputMode()); |
| } |
| |
| @Test |
| public void testAccessSplitTouchEnabled() throws Throwable { |
| mPopupWindow = createPopupWindow(createPopupContent(CONTENT_SIZE_DP, CONTENT_SIZE_DP)); |
| mActivityRule.runOnUiThread(() -> mPopupWindow.setSplitTouchEnabled(true)); |
| |
| showPopup(); |
| assertTrue(mPopupWindow.isSplitTouchEnabled()); |
| |
| dismissPopup(); |
| mActivityRule.runOnUiThread(() -> mPopupWindow.setSplitTouchEnabled(false)); |
| showPopup(); |
| assertFalse(mPopupWindow.isSplitTouchEnabled()); |
| |
| dismissPopup(); |
| mActivityRule.runOnUiThread(() -> mPopupWindow.setSplitTouchEnabled(true)); |
| showPopup(); |
| assertTrue(mPopupWindow.isSplitTouchEnabled()); |
| } |
| |
| @Test |
| public void testVerticallyClippedBeforeAdjusted() throws Throwable { |
| View parentWindowView = mActivity.getWindow().getDecorView(); |
| int parentWidth = parentWindowView.getMeasuredWidth(); |
| int parentHeight = parentWindowView.getMeasuredHeight(); |
| |
| // We make a popup which is too large to fit within the parent window. |
| // After showing it, we verify that it is shrunk to fit the window, |
| // rather than adjusted up. |
| mPopupWindow = createPopupWindow(createPopupContent(parentWidth*2, parentHeight*2)); |
| mPopupWindow.setWidth(WindowManager.LayoutParams.WRAP_CONTENT); |
| mPopupWindow.setHeight(WindowManager.LayoutParams.WRAP_CONTENT); |
| |
| showPopup(R.id.anchor_middle); |
| |
| View popupRoot = mPopupWindow.getContentView(); |
| int measuredWidth = popupRoot.getMeasuredWidth(); |
| int measuredHeight = popupRoot.getMeasuredHeight(); |
| View anchor = mActivity.findViewById(R.id.anchor_middle); |
| |
| // The popup should occupy all available vertical space. |
| int[] anchorLocationInWindowXY = new int[2]; |
| anchor.getLocationInWindow(anchorLocationInWindowXY); |
| assertEquals(measuredHeight, |
| parentHeight - (anchorLocationInWindowXY[1] + anchor.getHeight())); |
| |
| // The popup should be vertically aligned to the anchor's bottom edge. |
| int[] anchorLocationOnScreenXY = new int[2]; |
| anchor.getLocationOnScreen(anchorLocationOnScreenXY); |
| int[] popupLocationOnScreenXY = new int[2]; |
| popupRoot.getLocationOnScreen(popupLocationOnScreenXY); |
| assertEquals(anchorLocationOnScreenXY[1] + anchor.getHeight(), popupLocationOnScreenXY[1]); |
| } |
| |
| @Test |
| public void testClipToScreenClipsToInsets() throws Throwable { |
| int[] orientationValues = {ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE, |
| ActivityInfo.SCREEN_ORIENTATION_PORTRAIT}; |
| int currentOrientation = mActivity.getResources().getConfiguration().orientation; |
| if (currentOrientation == Configuration.ORIENTATION_LANDSCAPE) { |
| orientationValues[0] = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT; |
| orientationValues[1] = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE; |
| } |
| |
| for (int i = 0; i < 2; i++) { |
| final int orientation = orientationValues[i]; |
| if (orientation == ActivityInfo.SCREEN_ORIENTATION_PORTRAIT |
| && !hasDeviceFeature(PackageManager.FEATURE_SCREEN_PORTRAIT)) { |
| // skip test for devices not supporting portrait orientation |
| continue; |
| } |
| mActivity.runOnUiThread(() -> |
| mActivity.setRequestedOrientation(orientation)); |
| mActivity.waitForConfigurationChanged(); |
| // Wait for main thread to be idle to make sure layout and draw have been performed |
| // before continuing. |
| mInstrumentation.waitForIdleSync(); |
| |
| View parentWindowView = mActivity.getWindow().getDecorView(); |
| int parentWidth = parentWindowView.getMeasuredWidth(); |
| int parentHeight = parentWindowView.getMeasuredHeight(); |
| |
| mPopupWindow = createPopupWindow(createPopupContent(parentWidth*2, parentHeight*2)); |
| mPopupWindow.setWidth(WindowManager.LayoutParams.MATCH_PARENT); |
| mPopupWindow.setHeight(WindowManager.LayoutParams.MATCH_PARENT); |
| mPopupWindow.setClipToScreenEnabled(true); |
| |
| showPopup(R.id.anchor_upper_left); |
| |
| View popupRoot = mPopupWindow.getContentView().getRootView(); |
| int measuredWidth = popupRoot.getMeasuredWidth(); |
| int measuredHeight = popupRoot.getMeasuredHeight(); |
| |
| // The visible frame will not include the insets. |
| Rect visibleFrame = new Rect(); |
| parentWindowView.getWindowVisibleDisplayFrame(visibleFrame); |
| |
| assertEquals(measuredWidth, visibleFrame.width()); |
| assertEquals(measuredHeight, visibleFrame.height()); |
| } |
| } |
| |
| @Test |
| public void testPositionAfterParentScroll() throws Throwable { |
| View.OnScrollChangeListener scrollChangeListener = mock( |
| View.OnScrollChangeListener.class); |
| |
| mActivityRule.runOnUiThread(() -> { |
| mActivity.setContentView(R.layout.popup_window_scrollable); |
| |
| View anchor = mActivity.findViewById(R.id.anchor_upper); |
| PopupWindow window = createPopupWindow(); |
| window.showAsDropDown(anchor); |
| }); |
| |
| mActivityRule.runOnUiThread(() -> { |
| View parent = mActivity.findViewById(R.id.main_container); |
| parent.scrollBy(0, 500); |
| parent.setOnScrollChangeListener(scrollChangeListener); |
| }); |
| |
| verify(scrollChangeListener, never()).onScrollChange( |
| any(View.class), anyInt(), anyInt(), anyInt(), anyInt()); |
| } |
| |
| @Test |
| public void testPositionAfterAnchorRemoval() throws Throwable { |
| mPopupWindow = createPopupWindow(createPopupContent(CONTENT_SIZE_DP, CONTENT_SIZE_DP)); |
| showPopup(R.id.anchor_middle); |
| |
| final ViewGroup container = (ViewGroup) mActivity.findViewById(R.id.main_container); |
| final View anchor = mActivity.findViewById(R.id.anchor_middle); |
| final LayoutParams anchorLayoutParams = anchor.getLayoutParams(); |
| |
| final int[] originalLocation = mPopupWindow.getContentView().getLocationOnScreen(); |
| |
| final int deltaX = 30; |
| final int deltaY = 20; |
| |
| // Scroll the container, the popup should move along with the anchor. |
| WidgetTestUtils.runOnMainAndLayoutSync( |
| mActivityRule, |
| mPopupWindow.getContentView().getRootView(), |
| () -> container.scrollBy(deltaX, deltaY), |
| false /* force layout */); |
| // Since the first layout might have been caused by the original scroll event (and not by |
| // the anchor change), we need to wait until all traversals are done. |
| mInstrumentation.waitForIdleSync(); |
| assertPopupLocation(originalLocation, deltaX, deltaY); |
| |
| // Detach the anchor, the popup should stay in the same location. |
| WidgetTestUtils.runOnMainAndLayoutSync( |
| mActivityRule, |
| mActivity.getWindow().getDecorView(), |
| () -> container.removeView(anchor), |
| false /* force layout */); |
| assertPopupLocation(originalLocation, deltaX, deltaY); |
| |
| // Scroll the container while the anchor is detached, the popup should not move. |
| WidgetTestUtils.runOnMainAndLayoutSync( |
| mActivityRule, |
| mActivity.getWindow().getDecorView(), |
| () -> container.scrollBy(deltaX, deltaY), |
| true /* force layout */); |
| mInstrumentation.waitForIdleSync(); |
| assertPopupLocation(originalLocation, deltaX, deltaY); |
| |
| // Re-attach the anchor, the popup should snap back to the new anchor location. |
| WidgetTestUtils.runOnMainAndLayoutSync( |
| mActivityRule, |
| mPopupWindow.getContentView().getRootView(), |
| () -> container.addView(anchor, anchorLayoutParams), |
| false /* force layout */); |
| assertPopupLocation(originalLocation, deltaX * 2, deltaY * 2); |
| } |
| |
| @Test |
| public void testAnchorInPopup() throws Throwable { |
| DisplayMetrics displayMetrics = mActivity.getResources().getDisplayMetrics(); |
| float dpWidth = displayMetrics.widthPixels / displayMetrics.density; |
| float dpHeight = displayMetrics.heightPixels / displayMetrics.density; |
| final int minDisplaySize = 320; |
| if (dpWidth < minDisplaySize || dpHeight < minDisplaySize) { |
| // On smaller screens the popups that this test is creating |
| // are not guaranteed to be properly aligned to their anchors. |
| return; |
| } |
| |
| mPopupWindow = createPopupWindow( |
| mActivity.getLayoutInflater().inflate(R.layout.popup_window, null)); |
| |
| final PopupWindow subPopup = |
| createPopupWindow(createPopupContent(CONTENT_SIZE_DP, CONTENT_SIZE_DP)); |
| |
| // Check alignment without overlapping the anchor. |
| assertFalse(subPopup.getOverlapAnchor()); |
| |
| verifySubPopupPosition(subPopup, R.id.anchor_upper_left, R.id.anchor_lower_right, |
| LEFT, EQUAL_TO, LEFT, TOP, EQUAL_TO, BOTTOM); |
| verifySubPopupPosition(subPopup, R.id.anchor_middle_left, R.id.anchor_lower_right, |
| LEFT, EQUAL_TO, LEFT, TOP, EQUAL_TO, BOTTOM); |
| verifySubPopupPosition(subPopup, R.id.anchor_lower_left, R.id.anchor_lower_right, |
| LEFT, EQUAL_TO, LEFT, BOTTOM, EQUAL_TO, TOP); |
| |
| verifySubPopupPosition(subPopup, R.id.anchor_upper, R.id.anchor_lower_right, |
| LEFT, EQUAL_TO, LEFT, TOP, EQUAL_TO, BOTTOM); |
| verifySubPopupPosition(subPopup, R.id.anchor_middle, R.id.anchor_lower_right, |
| LEFT, EQUAL_TO, LEFT, TOP, EQUAL_TO, BOTTOM); |
| verifySubPopupPosition(subPopup, R.id.anchor_lower, R.id.anchor_lower_right, |
| LEFT, EQUAL_TO, LEFT, BOTTOM, EQUAL_TO, TOP); |
| |
| verifySubPopupPosition(subPopup, R.id.anchor_upper_right, R.id.anchor_lower_right, |
| RIGHT, EQUAL_TO, RIGHT, TOP, EQUAL_TO, BOTTOM); |
| verifySubPopupPosition(subPopup, R.id.anchor_middle_right, R.id.anchor_lower_right, |
| RIGHT, EQUAL_TO, RIGHT, TOP, EQUAL_TO, BOTTOM); |
| verifySubPopupPosition(subPopup, R.id.anchor_lower_right, R.id.anchor_lower_right, |
| RIGHT, EQUAL_TO, RIGHT, BOTTOM, EQUAL_TO, TOP); |
| |
| // Check alignment while overlapping the anchor. |
| subPopup.setOverlapAnchor(true); |
| |
| final int anchorHeight = mActivity.findViewById(R.id.anchor_lower_right).getHeight(); |
| // To simplify the math assert that all three lower anchors are the same height. |
| assertEquals(anchorHeight, mActivity.findViewById(R.id.anchor_lower_left).getHeight()); |
| assertEquals(anchorHeight, mActivity.findViewById(R.id.anchor_lower).getHeight()); |
| |
| final int verticalSpaceBelowAnchor = anchorHeight * 2; |
| // Ensure that the subpopup is flipped vertically. |
| subPopup.setHeight(verticalSpaceBelowAnchor + 1); |
| |
| verifySubPopupPosition(subPopup, R.id.anchor_upper_left, R.id.anchor_lower_right, |
| LEFT, EQUAL_TO, LEFT, TOP, EQUAL_TO, TOP); |
| verifySubPopupPosition(subPopup, R.id.anchor_middle_left, R.id.anchor_lower_right, |
| LEFT, EQUAL_TO, LEFT, TOP, EQUAL_TO, TOP); |
| verifySubPopupPosition(subPopup, R.id.anchor_lower_left, R.id.anchor_lower_right, |
| LEFT, EQUAL_TO, LEFT, BOTTOM, EQUAL_TO, TOP); |
| |
| verifySubPopupPosition(subPopup, R.id.anchor_upper, R.id.anchor_lower_right, |
| LEFT, EQUAL_TO, LEFT, TOP, EQUAL_TO, TOP); |
| verifySubPopupPosition(subPopup, R.id.anchor_middle, R.id.anchor_lower_right, |
| LEFT, EQUAL_TO, LEFT, TOP, EQUAL_TO, TOP); |
| verifySubPopupPosition(subPopup, R.id.anchor_lower, R.id.anchor_lower_right, |
| LEFT, EQUAL_TO, LEFT, BOTTOM, EQUAL_TO, TOP); |
| |
| verifySubPopupPosition(subPopup, R.id.anchor_upper_right, R.id.anchor_lower_right, |
| RIGHT, EQUAL_TO, RIGHT, TOP, EQUAL_TO, TOP); |
| verifySubPopupPosition(subPopup, R.id.anchor_middle_right, R.id.anchor_lower_right, |
| RIGHT, EQUAL_TO, RIGHT, TOP, EQUAL_TO, TOP); |
| verifySubPopupPosition(subPopup, R.id.anchor_lower_right, R.id.anchor_lower_right, |
| RIGHT, EQUAL_TO, RIGHT, BOTTOM, EQUAL_TO, TOP); |
| |
| // Re-test for the bottom anchor row ensuring that the subpopup not flipped vertically. |
| subPopup.setHeight(verticalSpaceBelowAnchor - 1); |
| |
| verifySubPopupPosition(subPopup, R.id.anchor_lower_left, R.id.anchor_lower_right, |
| LEFT, EQUAL_TO, LEFT, TOP, EQUAL_TO, TOP); |
| verifySubPopupPosition(subPopup, R.id.anchor_lower, R.id.anchor_lower_right, |
| LEFT, EQUAL_TO, LEFT, TOP, EQUAL_TO, TOP); |
| verifySubPopupPosition(subPopup, R.id.anchor_lower_right, R.id.anchor_lower_right, |
| RIGHT, EQUAL_TO, RIGHT, TOP, EQUAL_TO, TOP); |
| |
| // Check that scrolling scrolls the sub popup along with the main popup. |
| showPopup(R.id.anchor_middle); |
| |
| mActivityRule.runOnUiThread(() -> subPopup.showAsDropDown( |
| mPopupWindow.getContentView().findViewById(R.id.anchor_middle))); |
| mInstrumentation.waitForIdleSync(); |
| |
| final int[] popupLocation = mPopupWindow.getContentView().getLocationOnScreen(); |
| final int[] subPopupLocation = subPopup.getContentView().getLocationOnScreen(); |
| |
| final int deltaX = 20; |
| final int deltaY = 30; |
| |
| final ViewGroup container = (ViewGroup) mActivity.findViewById(R.id.main_container); |
| WidgetTestUtils.runOnMainAndLayoutSync( |
| mActivityRule, |
| subPopup.getContentView().getRootView(), |
| () -> container.scrollBy(deltaX, deltaY), |
| false /* force layout */); |
| |
| // Since the first layout might have been caused by the original scroll event (and not by |
| // the anchor change), we need to wait until all traversals are done. |
| mInstrumentation.waitForIdleSync(); |
| |
| final int[] newPopupLocation = mPopupWindow.getContentView().getLocationOnScreen(); |
| assertEquals(popupLocation[0] - deltaX, newPopupLocation[0]); |
| assertEquals(popupLocation[1] - deltaY, newPopupLocation[1]); |
| |
| final int[] newSubPopupLocation = subPopup.getContentView().getLocationOnScreen(); |
| assertEquals(subPopupLocation[0] - deltaX, newSubPopupLocation[0]); |
| assertEquals(subPopupLocation[1] - deltaY, newSubPopupLocation[1]); |
| } |
| |
| private void verifySubPopupPosition(PopupWindow subPopup, int mainAnchorId, int subAnchorId, |
| int contentEdgeX, int operatorX, int anchorEdgeX, |
| int contentEdgeY, int operatorY, int anchorEdgeY) throws Throwable { |
| showPopup(mainAnchorId); |
| verifyPosition(subPopup, mPopupWindow.getContentView().findViewById(subAnchorId), |
| contentEdgeX, operatorX, anchorEdgeX, contentEdgeY, operatorY, anchorEdgeY); |
| dismissPopup(); |
| } |
| |
| private void assertPopupLocation(int[] originalLocation, int deltaX, int deltaY) { |
| final int[] actualLocation = mPopupWindow.getContentView().getLocationOnScreen(); |
| assertEquals(originalLocation[0] - deltaX, actualLocation[0]); |
| assertEquals(originalLocation[1] - deltaY, actualLocation[1]); |
| } |
| |
| private static class BaseTransition extends Transition { |
| @Override |
| public void captureStartValues(TransitionValues transitionValues) {} |
| |
| @Override |
| public void captureEndValues(TransitionValues transitionValues) {} |
| } |
| |
| private View createPopupContent(int width, int height) { |
| final View popupView = new View(mActivity); |
| popupView.setLayoutParams(new ViewGroup.LayoutParams(width, height)); |
| popupView.setBackgroundColor(Color.MAGENTA); |
| |
| return popupView; |
| } |
| |
| private PopupWindow createPopupWindow() { |
| PopupWindow window = new PopupWindow(mActivity); |
| window.setWidth(WINDOW_SIZE_DP); |
| window.setHeight(WINDOW_SIZE_DP); |
| window.setBackgroundDrawable(new ColorDrawable(Color.YELLOW)); |
| return window; |
| } |
| |
| private PopupWindow createPopupWindow(View content) { |
| PopupWindow window = createPopupWindow(); |
| window.setContentView(content); |
| return window; |
| } |
| |
| private boolean hasDeviceFeature(final String requiredFeature) { |
| return mContext.getPackageManager().hasSystemFeature(requiredFeature); |
| } |
| |
| private void showPopup(int resourceId) throws Throwable { |
| mActivityRule.runOnUiThread(() -> { |
| if (mPopupWindow == null || mPopupWindow.isShowing()) { |
| return; |
| } |
| View anchor = mActivity.findViewById(resourceId); |
| mPopupWindow.showAsDropDown(anchor); |
| assertTrue(mPopupWindow.isShowing()); |
| }); |
| mInstrumentation.waitForIdleSync(); |
| } |
| |
| private void showPopup() throws Throwable { |
| showPopup(R.id.anchor_upper_left); |
| } |
| |
| private void dismissPopup() throws Throwable { |
| mActivityRule.runOnUiThread(() -> { |
| if (mPopupWindow == null || !mPopupWindow.isShowing()) { |
| return; |
| } |
| mPopupWindow.dismiss(); |
| }); |
| mInstrumentation.waitForIdleSync(); |
| } |
| } |
