| /* |
| * 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; |
| |
| import android.content.BroadcastReceiver; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.IntentFilter; |
| import android.graphics.PixelFormat; |
| import android.graphics.Rect; |
| import android.os.Handler; |
| import android.os.Message; |
| import android.util.Log; |
| import android.view.Gravity; |
| import android.view.KeyEvent; |
| import android.view.LayoutInflater; |
| import android.view.MotionEvent; |
| import android.view.View; |
| import android.view.View.OnClickListener; |
| import android.view.ViewConfiguration; |
| import android.view.ViewGroup; |
| import android.view.ViewRootImpl; |
| import android.view.WindowManager; |
| import android.view.WindowManager.LayoutParams; |
| |
| /* |
| * Implementation notes: |
| * - The zoom controls are displayed in their own window. |
| * (Easier for the client and better performance) |
| * - This window is never touchable, and by default is not focusable. |
| * Its rect is quite big (fills horizontally) but has empty space between the |
| * edges and center. Touches there should be given to the owner. Instead of |
| * having the window touchable and dispatching these empty touch events to the |
| * owner, we set the window to not touchable and steal events from owner |
| * via onTouchListener. |
| * - To make the buttons clickable, it attaches an OnTouchListener to the owner |
| * view and does the hit detection locally (attaches when visible, detaches when invisible). |
| * - When it is focusable, it forwards uninteresting events to the owner view's |
| * view hierarchy. |
| */ |
| /** |
| * The {@link ZoomButtonsController} handles showing and hiding the zoom |
| * controls and positioning it relative to an owner view. It also gives the |
| * client access to the zoom controls container, allowing for additional |
| * accessory buttons to be shown in the zoom controls window. |
| * <p> |
| * Typically, clients should call {@link #setVisible(boolean) setVisible(true)} |
| * on a touch down or move (no need to call {@link #setVisible(boolean) |
| * setVisible(false)} since it will time out on its own). Also, whenever the |
| * owner cannot be zoomed further, the client should update |
| * {@link #setZoomInEnabled(boolean)} and {@link #setZoomOutEnabled(boolean)}. |
| * <p> |
| * If you are using this with a custom View, please call |
| * {@link #setVisible(boolean) setVisible(false)} from |
| * {@link View#onDetachedFromWindow} and from {@link View#onVisibilityChanged} |
| * when <code>visibility != View.VISIBLE</code>. |
| * |
| * @deprecated This functionality and UI is better handled with custom views and layouts |
| * rather than a dedicated zoom-control widget |
| */ |
| @Deprecated |
| public class ZoomButtonsController implements View.OnTouchListener { |
| |
| private static final String TAG = "ZoomButtonsController"; |
| |
| private static final int ZOOM_CONTROLS_TIMEOUT = |
| (int) ViewConfiguration.getZoomControlsTimeout(); |
| |
| private static final int ZOOM_CONTROLS_TOUCH_PADDING = 20; |
| private int mTouchPaddingScaledSq; |
| |
| private final Context mContext; |
| private final WindowManager mWindowManager; |
| private boolean mAutoDismissControls = true; |
| |
| /** |
| * The view that is being zoomed by this zoom controller. |
| */ |
| private final View mOwnerView; |
| |
| /** |
| * The location of the owner view on the screen. This is recalculated |
| * each time the zoom controller is shown. |
| */ |
| private final int[] mOwnerViewRawLocation = new int[2]; |
| |
| /** |
| * The container that is added as a window. |
| */ |
| private final FrameLayout mContainer; |
| private LayoutParams mContainerLayoutParams; |
| private final int[] mContainerRawLocation = new int[2]; |
| |
| private ZoomControls mControls; |
| |
| /** |
| * The view (or null) that should receive touch events. This will get set if |
| * the touch down hits the container. It will be reset on the touch up. |
| */ |
| private View mTouchTargetView; |
| /** |
| * The {@link #mTouchTargetView}'s location in window, set on touch down. |
| */ |
| private final int[] mTouchTargetWindowLocation = new int[2]; |
| |
| /** |
| * If the zoom controller is dismissed but the user is still in a touch |
| * interaction, we set this to true. This will ignore all touch events until |
| * up/cancel, and then set the owner's touch listener to null. |
| * <p> |
| * Otherwise, the owner view would get mismatched events (i.e., touch move |
| * even though it never got the touch down.) |
| */ |
| private boolean mReleaseTouchListenerOnUp; |
| |
| /** Whether the container has been added to the window manager. */ |
| private boolean mIsVisible; |
| |
| private final Rect mTempRect = new Rect(); |
| private final int[] mTempIntArray = new int[2]; |
| |
| private OnZoomListener mCallback; |
| |
| /** |
| * When showing the zoom, we add the view as a new window. However, there is |
| * logic that needs to know the size of the zoom which is determined after |
| * it's laid out. Therefore, we must post this logic onto the UI thread so |
| * it will be exceuted AFTER the layout. This is the logic. |
| */ |
| private Runnable mPostedVisibleInitializer; |
| |
| private final IntentFilter mConfigurationChangedFilter = |
| new IntentFilter(Intent.ACTION_CONFIGURATION_CHANGED); |
| |
| /** |
| * Needed to reposition the zoom controls after configuration changes. |
| */ |
| private final BroadcastReceiver mConfigurationChangedReceiver = new BroadcastReceiver() { |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| if (!mIsVisible) return; |
| |
| mHandler.removeMessages(MSG_POST_CONFIGURATION_CHANGED); |
| mHandler.sendEmptyMessage(MSG_POST_CONFIGURATION_CHANGED); |
| } |
| }; |
| |
| /** When configuration changes, this is called after the UI thread is idle. */ |
| private static final int MSG_POST_CONFIGURATION_CHANGED = 2; |
| /** Used to delay the zoom controller dismissal. */ |
| private static final int MSG_DISMISS_ZOOM_CONTROLS = 3; |
| /** |
| * If setVisible(true) is called and the owner view's window token is null, |
| * we delay the setVisible(true) call until it is not null. |
| */ |
| private static final int MSG_POST_SET_VISIBLE = 4; |
| |
| private final Handler mHandler = new Handler() { |
| @Override |
| public void handleMessage(Message msg) { |
| switch (msg.what) { |
| case MSG_POST_CONFIGURATION_CHANGED: |
| onPostConfigurationChanged(); |
| break; |
| |
| case MSG_DISMISS_ZOOM_CONTROLS: |
| setVisible(false); |
| break; |
| |
| case MSG_POST_SET_VISIBLE: |
| if (mOwnerView.getWindowToken() == null) { |
| // Doh, it is still null, just ignore the set visible call |
| Log.e(TAG, |
| "Cannot make the zoom controller visible if the owner view is " + |
| "not attached to a window."); |
| } else { |
| setVisible(true); |
| } |
| break; |
| } |
| |
| } |
| }; |
| |
| /** |
| * Constructor for the {@link ZoomButtonsController}. |
| * |
| * @param ownerView The view that is being zoomed by the zoom controls. The |
| * zoom controls will be displayed aligned with this view. |
| */ |
| public ZoomButtonsController(View ownerView) { |
| mContext = ownerView.getContext(); |
| mWindowManager = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE); |
| mOwnerView = ownerView; |
| |
| mTouchPaddingScaledSq = (int) |
| (ZOOM_CONTROLS_TOUCH_PADDING * mContext.getResources().getDisplayMetrics().density); |
| mTouchPaddingScaledSq *= mTouchPaddingScaledSq; |
| |
| mContainer = createContainer(); |
| } |
| |
| /** |
| * Whether to enable the zoom in control. |
| * |
| * @param enabled Whether to enable the zoom in control. |
| */ |
| public void setZoomInEnabled(boolean enabled) { |
| mControls.setIsZoomInEnabled(enabled); |
| } |
| |
| /** |
| * Whether to enable the zoom out control. |
| * |
| * @param enabled Whether to enable the zoom out control. |
| */ |
| public void setZoomOutEnabled(boolean enabled) { |
| mControls.setIsZoomOutEnabled(enabled); |
| } |
| |
| /** |
| * Sets the delay between zoom callbacks as the user holds a zoom button. |
| * |
| * @param speed The delay in milliseconds between zoom callbacks. |
| */ |
| public void setZoomSpeed(long speed) { |
| mControls.setZoomSpeed(speed); |
| } |
| |
| private FrameLayout createContainer() { |
| LayoutParams lp = new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT); |
| // Controls are positioned BOTTOM | CENTER with respect to the owner view. |
| lp.gravity = Gravity.TOP | Gravity.START; |
| lp.flags = LayoutParams.FLAG_NOT_TOUCHABLE | |
| LayoutParams.FLAG_NOT_FOCUSABLE | |
| LayoutParams.FLAG_LAYOUT_NO_LIMITS | |
| LayoutParams.FLAG_ALT_FOCUSABLE_IM; |
| lp.height = LayoutParams.WRAP_CONTENT; |
| lp.width = LayoutParams.MATCH_PARENT; |
| lp.type = LayoutParams.TYPE_APPLICATION_PANEL; |
| lp.format = PixelFormat.TRANSLUCENT; |
| lp.windowAnimations = com.android.internal.R.style.Animation_ZoomButtons; |
| mContainerLayoutParams = lp; |
| |
| FrameLayout container = new Container(mContext); |
| container.setLayoutParams(lp); |
| container.setMeasureAllChildren(true); |
| |
| LayoutInflater inflater = (LayoutInflater) mContext |
| .getSystemService(Context.LAYOUT_INFLATER_SERVICE); |
| inflater.inflate(com.android.internal.R.layout.zoom_container, container); |
| |
| mControls = container.findViewById(com.android.internal.R.id.zoomControls); |
| mControls.setOnZoomInClickListener(new OnClickListener() { |
| public void onClick(View v) { |
| dismissControlsDelayed(ZOOM_CONTROLS_TIMEOUT); |
| if (mCallback != null) mCallback.onZoom(true); |
| } |
| }); |
| mControls.setOnZoomOutClickListener(new OnClickListener() { |
| public void onClick(View v) { |
| dismissControlsDelayed(ZOOM_CONTROLS_TIMEOUT); |
| if (mCallback != null) mCallback.onZoom(false); |
| } |
| }); |
| |
| return container; |
| } |
| |
| /** |
| * Sets the {@link OnZoomListener} listener that receives callbacks to zoom. |
| * |
| * @param listener The listener that will be told to zoom. |
| */ |
| public void setOnZoomListener(OnZoomListener listener) { |
| mCallback = listener; |
| } |
| |
| /** |
| * Sets whether the zoom controls should be focusable. If the controls are |
| * focusable, then trackball and arrow key interactions are possible. |
| * Otherwise, only touch interactions are possible. |
| * |
| * @param focusable Whether the zoom controls should be focusable. |
| */ |
| public void setFocusable(boolean focusable) { |
| int oldFlags = mContainerLayoutParams.flags; |
| if (focusable) { |
| mContainerLayoutParams.flags &= ~LayoutParams.FLAG_NOT_FOCUSABLE; |
| } else { |
| mContainerLayoutParams.flags |= LayoutParams.FLAG_NOT_FOCUSABLE; |
| } |
| |
| if ((mContainerLayoutParams.flags != oldFlags) && mIsVisible) { |
| mWindowManager.updateViewLayout(mContainer, mContainerLayoutParams); |
| } |
| } |
| |
| /** |
| * Whether the zoom controls will be automatically dismissed after showing. |
| * |
| * @return Whether the zoom controls will be auto dismissed after showing. |
| */ |
| public boolean isAutoDismissed() { |
| return mAutoDismissControls; |
| } |
| |
| /** |
| * Sets whether the zoom controls will be automatically dismissed after |
| * showing. |
| */ |
| public void setAutoDismissed(boolean autoDismiss) { |
| if (mAutoDismissControls == autoDismiss) return; |
| mAutoDismissControls = autoDismiss; |
| } |
| |
| /** |
| * Whether the zoom controls are visible to the user. |
| * |
| * @return Whether the zoom controls are visible to the user. |
| */ |
| public boolean isVisible() { |
| return mIsVisible; |
| } |
| |
| /** |
| * Sets whether the zoom controls should be visible to the user. |
| * |
| * @param visible Whether the zoom controls should be visible to the user. |
| */ |
| public void setVisible(boolean visible) { |
| |
| if (visible) { |
| if (mOwnerView.getWindowToken() == null) { |
| /* |
| * We need a window token to show ourselves, maybe the owner's |
| * window hasn't been created yet but it will have been by the |
| * time the looper is idle, so post the setVisible(true) call. |
| */ |
| if (!mHandler.hasMessages(MSG_POST_SET_VISIBLE)) { |
| mHandler.sendEmptyMessage(MSG_POST_SET_VISIBLE); |
| } |
| return; |
| } |
| |
| dismissControlsDelayed(ZOOM_CONTROLS_TIMEOUT); |
| } |
| |
| if (mIsVisible == visible) { |
| return; |
| } |
| mIsVisible = visible; |
| |
| if (visible) { |
| if (mContainerLayoutParams.token == null) { |
| mContainerLayoutParams.token = mOwnerView.getWindowToken(); |
| } |
| |
| mWindowManager.addView(mContainer, mContainerLayoutParams); |
| |
| if (mPostedVisibleInitializer == null) { |
| mPostedVisibleInitializer = new Runnable() { |
| public void run() { |
| refreshPositioningVariables(); |
| |
| if (mCallback != null) { |
| mCallback.onVisibilityChanged(true); |
| } |
| } |
| }; |
| } |
| |
| mHandler.post(mPostedVisibleInitializer); |
| |
| // Handle configuration changes when visible |
| mContext.registerReceiver(mConfigurationChangedReceiver, mConfigurationChangedFilter); |
| |
| // Steal touches events from the owner |
| mOwnerView.setOnTouchListener(this); |
| mReleaseTouchListenerOnUp = false; |
| |
| } else { |
| // Don't want to steal any more touches |
| if (mTouchTargetView != null) { |
| // We are still stealing the touch events for this touch |
| // sequence, so release the touch listener later |
| mReleaseTouchListenerOnUp = true; |
| } else { |
| mOwnerView.setOnTouchListener(null); |
| } |
| |
| // No longer care about configuration changes |
| mContext.unregisterReceiver(mConfigurationChangedReceiver); |
| |
| mWindowManager.removeViewImmediate(mContainer); |
| mHandler.removeCallbacks(mPostedVisibleInitializer); |
| |
| if (mCallback != null) { |
| mCallback.onVisibilityChanged(false); |
| } |
| } |
| |
| } |
| |
| /** |
| * Gets the container that is the parent of the zoom controls. |
| * <p> |
| * The client can add other views to this container to link them with the |
| * zoom controls. |
| * |
| * @return The container of the zoom controls. It will be a layout that |
| * respects the gravity of a child's layout parameters. |
| */ |
| public ViewGroup getContainer() { |
| return mContainer; |
| } |
| |
| /** |
| * Gets the view for the zoom controls. |
| * |
| * @return The zoom controls view. |
| */ |
| public View getZoomControls() { |
| return mControls; |
| } |
| |
| private void dismissControlsDelayed(int delay) { |
| if (mAutoDismissControls) { |
| mHandler.removeMessages(MSG_DISMISS_ZOOM_CONTROLS); |
| mHandler.sendEmptyMessageDelayed(MSG_DISMISS_ZOOM_CONTROLS, delay); |
| } |
| } |
| |
| private void refreshPositioningVariables() { |
| // if the mOwnerView is detached from window then skip. |
| if (mOwnerView.getWindowToken() == null) return; |
| |
| // Position the zoom controls on the bottom of the owner view. |
| int ownerHeight = mOwnerView.getHeight(); |
| int ownerWidth = mOwnerView.getWidth(); |
| // The gap between the top of the owner and the top of the container |
| int containerOwnerYOffset = ownerHeight - mContainer.getHeight(); |
| |
| // Calculate the owner view's bounds |
| mOwnerView.getLocationOnScreen(mOwnerViewRawLocation); |
| mContainerRawLocation[0] = mOwnerViewRawLocation[0]; |
| mContainerRawLocation[1] = mOwnerViewRawLocation[1] + containerOwnerYOffset; |
| |
| int[] ownerViewWindowLoc = mTempIntArray; |
| mOwnerView.getLocationInWindow(ownerViewWindowLoc); |
| |
| // lp.x and lp.y should be relative to the owner's window top-left |
| mContainerLayoutParams.x = ownerViewWindowLoc[0]; |
| mContainerLayoutParams.width = ownerWidth; |
| mContainerLayoutParams.y = ownerViewWindowLoc[1] + containerOwnerYOffset; |
| if (mIsVisible) { |
| mWindowManager.updateViewLayout(mContainer, mContainerLayoutParams); |
| } |
| |
| } |
| |
| /* This will only be called when the container has focus. */ |
| private boolean onContainerKey(KeyEvent event) { |
| int keyCode = event.getKeyCode(); |
| if (isInterestingKey(keyCode)) { |
| |
| if (keyCode == KeyEvent.KEYCODE_BACK) { |
| if (event.getAction() == KeyEvent.ACTION_DOWN |
| && event.getRepeatCount() == 0) { |
| if (mOwnerView != null) { |
| KeyEvent.DispatcherState ds = mOwnerView.getKeyDispatcherState(); |
| if (ds != null) { |
| ds.startTracking(event, this); |
| } |
| } |
| return true; |
| } else if (event.getAction() == KeyEvent.ACTION_UP |
| && event.isTracking() && !event.isCanceled()) { |
| setVisible(false); |
| return true; |
| } |
| |
| } else { |
| dismissControlsDelayed(ZOOM_CONTROLS_TIMEOUT); |
| } |
| |
| // Let the container handle the key |
| return false; |
| |
| } else { |
| |
| ViewRootImpl viewRoot = mOwnerView.getViewRootImpl(); |
| if (viewRoot != null) { |
| viewRoot.dispatchInputEvent(event); |
| } |
| |
| // We gave the key to the owner, don't let the container handle this key |
| return true; |
| } |
| } |
| |
| private boolean isInterestingKey(int keyCode) { |
| switch (keyCode) { |
| case KeyEvent.KEYCODE_DPAD_CENTER: |
| case KeyEvent.KEYCODE_DPAD_UP: |
| case KeyEvent.KEYCODE_DPAD_DOWN: |
| case KeyEvent.KEYCODE_DPAD_LEFT: |
| case KeyEvent.KEYCODE_DPAD_RIGHT: |
| case KeyEvent.KEYCODE_ENTER: |
| case KeyEvent.KEYCODE_BACK: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| /** |
| * @hide The ZoomButtonsController implements the OnTouchListener, but this |
| * does not need to be shown in its public API. |
| */ |
| public boolean onTouch(View v, MotionEvent event) { |
| int action = event.getAction(); |
| |
| if (event.getPointerCount() > 1) { |
| // ZoomButtonsController doesn't handle mutitouch. Give up control. |
| return false; |
| } |
| |
| if (mReleaseTouchListenerOnUp) { |
| // The controls were dismissed but we need to throw away all events until the up |
| if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) { |
| mOwnerView.setOnTouchListener(null); |
| setTouchTargetView(null); |
| mReleaseTouchListenerOnUp = false; |
| } |
| |
| // Eat this event |
| return true; |
| } |
| |
| dismissControlsDelayed(ZOOM_CONTROLS_TIMEOUT); |
| |
| View targetView = mTouchTargetView; |
| |
| switch (action) { |
| case MotionEvent.ACTION_DOWN: |
| targetView = findViewForTouch((int) event.getRawX(), (int) event.getRawY()); |
| setTouchTargetView(targetView); |
| break; |
| |
| case MotionEvent.ACTION_UP: |
| case MotionEvent.ACTION_CANCEL: |
| setTouchTargetView(null); |
| break; |
| } |
| |
| if (targetView != null) { |
| // The upperleft corner of the target view in raw coordinates |
| int targetViewRawX = mContainerRawLocation[0] + mTouchTargetWindowLocation[0]; |
| int targetViewRawY = mContainerRawLocation[1] + mTouchTargetWindowLocation[1]; |
| |
| MotionEvent containerEvent = MotionEvent.obtain(event); |
| // Convert the motion event into the target view's coordinates (from |
| // owner view's coordinates) |
| containerEvent.offsetLocation(mOwnerViewRawLocation[0] - targetViewRawX, |
| mOwnerViewRawLocation[1] - targetViewRawY); |
| /* Disallow negative coordinates (which can occur due to |
| * ZOOM_CONTROLS_TOUCH_PADDING) */ |
| // These are floats because we need to potentially offset away this exact amount |
| float containerX = containerEvent.getX(); |
| float containerY = containerEvent.getY(); |
| if (containerX < 0 && containerX > -ZOOM_CONTROLS_TOUCH_PADDING) { |
| containerEvent.offsetLocation(-containerX, 0); |
| } |
| if (containerY < 0 && containerY > -ZOOM_CONTROLS_TOUCH_PADDING) { |
| containerEvent.offsetLocation(0, -containerY); |
| } |
| boolean retValue = targetView.dispatchTouchEvent(containerEvent); |
| containerEvent.recycle(); |
| return retValue; |
| |
| } else { |
| return false; |
| } |
| } |
| |
| private void setTouchTargetView(View view) { |
| mTouchTargetView = view; |
| if (view != null) { |
| view.getLocationInWindow(mTouchTargetWindowLocation); |
| } |
| } |
| |
| /** |
| * Returns the View that should receive a touch at the given coordinates. |
| * |
| * @param rawX The raw X. |
| * @param rawY The raw Y. |
| * @return The view that should receive the touches, or null if there is not one. |
| */ |
| private View findViewForTouch(int rawX, int rawY) { |
| // Reverse order so the child drawn on top gets first dibs. |
| int containerCoordsX = rawX - mContainerRawLocation[0]; |
| int containerCoordsY = rawY - mContainerRawLocation[1]; |
| Rect frame = mTempRect; |
| |
| View closestChild = null; |
| int closestChildDistanceSq = Integer.MAX_VALUE; |
| |
| for (int i = mContainer.getChildCount() - 1; i >= 0; i--) { |
| View child = mContainer.getChildAt(i); |
| if (child.getVisibility() != View.VISIBLE) { |
| continue; |
| } |
| |
| child.getHitRect(frame); |
| if (frame.contains(containerCoordsX, containerCoordsY)) { |
| return child; |
| } |
| |
| int distanceX; |
| if (containerCoordsX >= frame.left && containerCoordsX <= frame.right) { |
| distanceX = 0; |
| } else { |
| distanceX = Math.min(Math.abs(frame.left - containerCoordsX), |
| Math.abs(containerCoordsX - frame.right)); |
| } |
| int distanceY; |
| if (containerCoordsY >= frame.top && containerCoordsY <= frame.bottom) { |
| distanceY = 0; |
| } else { |
| distanceY = Math.min(Math.abs(frame.top - containerCoordsY), |
| Math.abs(containerCoordsY - frame.bottom)); |
| } |
| int distanceSq = distanceX * distanceX + distanceY * distanceY; |
| |
| if ((distanceSq < mTouchPaddingScaledSq) && |
| (distanceSq < closestChildDistanceSq)) { |
| closestChild = child; |
| closestChildDistanceSq = distanceSq; |
| } |
| } |
| |
| return closestChild; |
| } |
| |
| private void onPostConfigurationChanged() { |
| dismissControlsDelayed(ZOOM_CONTROLS_TIMEOUT); |
| refreshPositioningVariables(); |
| } |
| |
| /** |
| * Interface that will be called when the user performs an interaction that |
| * triggers some action, for example zooming. |
| */ |
| public interface OnZoomListener { |
| |
| /** |
| * Called when the zoom controls' visibility changes. |
| * |
| * @param visible Whether the zoom controls are visible. |
| */ |
| void onVisibilityChanged(boolean visible); |
| |
| /** |
| * Called when the owner view needs to be zoomed. |
| * |
| * @param zoomIn The direction of the zoom: true to zoom in, false to zoom out. |
| */ |
| void onZoom(boolean zoomIn); |
| } |
| |
| private class Container extends FrameLayout { |
| public Container(Context context) { |
| super(context); |
| } |
| |
| /* |
| * Need to override this to intercept the key events. Otherwise, we |
| * would attach a key listener to the container but its superclass |
| * ViewGroup gives it to the focused View instead of calling the key |
| * listener, and so we wouldn't get the events. |
| */ |
| @Override |
| public boolean dispatchKeyEvent(KeyEvent event) { |
| return onContainerKey(event) ? true : super.dispatchKeyEvent(event); |
| } |
| } |
| |
| } |
