Refactor the on-screen zoom controls into a separate class. (90b6e487) · Commits · e / os / android_frameworks_base

core/java/android/webkit/WebView.java

+85 −323

File changed.

Preview size limit exceeded, changes collapsed.

core/java/android/webkit/ZoomControlBase.java

0 → 100644

+41 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2010 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.webkit;

		interface ZoomControlBase {

		/**
		* Causes the on-screen zoom control to be made visible
		*/
		public void show();

		/**
		* Causes the on-screen zoom control to disappear
		*/
		public void hide();

		/**
		* Enables the control to update its state if necessary in response to a
		* change in the pages zoom level. For example, if the max zoom level is
		* reached then the control can disable the button for zooming in.
		*/
		public void update();

		/**
		* Checks to see if the control is currently visible to the user.
		*/
		public boolean isVisible();
		}

core/java/android/webkit/ZoomControlEmbedded.java

0 → 100644

+119 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2010 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.webkit;

		import android.view.Gravity;
		import android.view.View;
		import android.view.ViewGroup;
		import android.widget.FrameLayout;
		import android.widget.Toast;
		import android.widget.ZoomButtonsController;

		class ZoomControlEmbedded implements ZoomControlBase {

		private final ZoomManager mZoomManager;
		private final WebView mWebView;

		// The controller is lazily initialized in getControls() for performance.
		private ZoomButtonsController mZoomButtonsController;

		public ZoomControlEmbedded(ZoomManager zoomManager, WebView webView) {
		mZoomManager = zoomManager;
		mWebView = webView;
		}

		public void show() {
		if (!getControls().isVisible()
		&& mZoomManager.mMinZoomScale < mZoomManager.mMaxZoomScale) {

		mZoomButtonsController.setVisible(true);

		WebSettings settings = mWebView.getSettings();
		int count = settings.getDoubleTapToastCount();
		if (mZoomManager.mInZoomOverview && count > 0) {
		settings.setDoubleTapToastCount(--count);
		Toast.makeText(mWebView.getContext(),
		com.android.internal.R.string.double_tap_toast,
		Toast.LENGTH_LONG).show();
		}
		}
		}

		public void hide() {
		if (mZoomButtonsController != null) {
		mZoomButtonsController.setVisible(false);
		}
		}

		public boolean isVisible() {
		return mZoomButtonsController != null && mZoomButtonsController.isVisible();
		}

		public void update() {
		if (mZoomButtonsController == null) {
		return;
		}

		boolean canZoomIn = mWebView.getScale() < mZoomManager.mMaxZoomScale;
		boolean canZoomOut = mWebView.getScale() > mZoomManager.mMinZoomScale &&
		!mZoomManager.mInZoomOverview;
		if (!canZoomIn && !canZoomOut) {
		// Hide the zoom in and out buttons if the page cannot zoom
		mZoomButtonsController.getZoomControls().setVisibility(View.GONE);
		} else {
		// Set each one individually, as a page may be able to zoom in or out
		mZoomButtonsController.setZoomInEnabled(canZoomIn);
		mZoomButtonsController.setZoomOutEnabled(canZoomOut);
		}
		}

		private ZoomButtonsController getControls() {
		if (mZoomButtonsController == null) {
		mZoomButtonsController = new ZoomButtonsController(mWebView);
		mZoomButtonsController.setOnZoomListener(new ZoomListener());
		// ZoomButtonsController positions the buttons at the bottom, but in
		// the middle. Change their layout parameters so they appear on the
		// right.
		View controls = mZoomButtonsController.getZoomControls();
		ViewGroup.LayoutParams params = controls.getLayoutParams();
		if (params instanceof FrameLayout.LayoutParams) {
		((FrameLayout.LayoutParams) params).gravity = Gravity.RIGHT;
		}
		}
		return mZoomButtonsController;
		}

		private class ZoomListener implements ZoomButtonsController.OnZoomListener {

		public void onVisibilityChanged(boolean visible) {
		if (visible) {
		mWebView.switchOutDrawHistory();
		// Bring back the hidden zoom controls.
		mZoomButtonsController.getZoomControls().setVisibility(View.VISIBLE);
		update();
		}
		}

		public void onZoom(boolean zoomIn) {
		if (zoomIn) {
		mWebView.zoomIn();
		} else {
		mWebView.zoomOut();
		}
		update();
		}
		}
		}

core/java/android/webkit/ZoomControlExternal.java

0 → 100644

+159 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2010 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.webkit;

		import android.content.Context;
		import android.os.Handler;
		import android.view.LayoutInflater;
		import android.view.View;
		import android.view.ViewConfiguration;
		import android.view.View.OnClickListener;
		import android.view.animation.AlphaAnimation;
		import android.widget.FrameLayout;

		@Deprecated
		class ZoomControlExternal implements ZoomControlBase {

		// The time that the external controls are visible before fading away
		private static final long ZOOM_CONTROLS_TIMEOUT =
		ViewConfiguration.getZoomControlsTimeout();
		// The view containing the external zoom controls
		private ExtendedZoomControls mZoomControls;
		private Runnable mZoomControlRunnable;
		private final Handler mPrivateHandler = new Handler();

		private final WebView mWebView;

		public ZoomControlExternal(WebView webView) {
		mWebView = webView;
		}

		public void show() {
		if(mZoomControlRunnable != null) {
		mPrivateHandler.removeCallbacks(mZoomControlRunnable);
		}
		getControls().show(true);
		mPrivateHandler.postDelayed(mZoomControlRunnable, ZOOM_CONTROLS_TIMEOUT);
		}

		public void hide() {
		if (mZoomControlRunnable != null) {
		mPrivateHandler.removeCallbacks(mZoomControlRunnable);
		}
		if (mZoomControls != null) {
		mZoomControls.hide();
		}
		}

		public boolean isVisible() {
		return mZoomControls != null && mZoomControls.isShown();
		}

		public void update() { }

		public ExtendedZoomControls getControls() {
		if (mZoomControls == null) {
		mZoomControls = createZoomControls();

		/*
		* need to be set to VISIBLE first so that getMeasuredHeight() in
		* {@link #onSizeChanged()} can return the measured value for proper
		* layout.
		*/
		mZoomControls.setVisibility(View.VISIBLE);
		mZoomControlRunnable = new Runnable() {
		public void run() {
		/* Don't dismiss the controls if the user has
		* focus on them. Wait and check again later.
		*/
		if (!mZoomControls.hasFocus()) {
		mZoomControls.hide();
		} else {
		mPrivateHandler.removeCallbacks(mZoomControlRunnable);
		mPrivateHandler.postDelayed(mZoomControlRunnable,
		ZOOM_CONTROLS_TIMEOUT);
		}
		}
		};
		}
		return mZoomControls;
		}

		private ExtendedZoomControls createZoomControls() {
		ExtendedZoomControls zoomControls = new ExtendedZoomControls(mWebView.getContext());
		zoomControls.setOnZoomInClickListener(new OnClickListener() {
		public void onClick(View v) {
		// reset time out
		mPrivateHandler.removeCallbacks(mZoomControlRunnable);
		mPrivateHandler.postDelayed(mZoomControlRunnable, ZOOM_CONTROLS_TIMEOUT);
		mWebView.zoomIn();
		}
		});
		zoomControls.setOnZoomOutClickListener(new OnClickListener() {
		public void onClick(View v) {
		// reset time out
		mPrivateHandler.removeCallbacks(mZoomControlRunnable);
		mPrivateHandler.postDelayed(mZoomControlRunnable, ZOOM_CONTROLS_TIMEOUT);
		mWebView.zoomOut();
		}
		});
		return zoomControls;
		}

		private static class ExtendedZoomControls extends FrameLayout {

		private android.widget.ZoomControls mPlusMinusZoomControls;

		public ExtendedZoomControls(Context context) {
		super(context, null);
		LayoutInflater inflater = (LayoutInflater)
		context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
		inflater.inflate(com.android.internal.R.layout.zoom_magnify, this, true);
		mPlusMinusZoomControls = (android.widget.ZoomControls) findViewById(
		com.android.internal.R.id.zoomControls);
		findViewById(com.android.internal.R.id.zoomMagnify).setVisibility(
		View.GONE);
		}

		public void show(boolean showZoom) {
		mPlusMinusZoomControls.setVisibility(showZoom ? View.VISIBLE : View.GONE);
		fade(View.VISIBLE, 0.0f, 1.0f);
		}

		public void hide() {
		fade(View.GONE, 1.0f, 0.0f);
		}

		private void fade(int visibility, float startAlpha, float endAlpha) {
		AlphaAnimation anim = new AlphaAnimation(startAlpha, endAlpha);
		anim.setDuration(500);
		startAnimation(anim);
		setVisibility(visibility);
		}

		public boolean hasFocus() {
		return mPlusMinusZoomControls.hasFocus();
		}

		public void setOnZoomInClickListener(OnClickListener listener) {
		mPlusMinusZoomControls.setOnZoomInClickListener(listener);
		}

		public void setOnZoomOutClickListener(OnClickListener listener) {
		mPlusMinusZoomControls.setOnZoomOutClickListener(listener);
		}
		}
		}

core/java/android/webkit/ZoomManager.java

0 → 100644

+128 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2010 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.webkit;

		import android.view.View;

		class ZoomManager {

		static final String LOGTAG = "webviewZoom";

		private final WebView mWebView;

		// manages the on-screen zoom functions of the WebView
		private ZoomControlEmbedded mEmbeddedZoomControl;

		private ZoomControlExternal mExternalZoomControl;

		/*
		* TODO: clean up the visibility of the class variables when the zoom
		* refactoring is complete
		*/

		// default scale limits, which are dependent on the display density
		static float DEFAULT_MAX_ZOOM_SCALE;
		static float DEFAULT_MIN_ZOOM_SCALE;

		// actual scale limits, which can be set through a webpage viewport meta tag
		float mMaxZoomScale;
		float mMinZoomScale;

		// locks the minimum ZoomScale to the value currently set in mMinZoomScale
		boolean mMinZoomScaleFixed = true;

		// while in the zoom overview mode, the page's width is fully fit to the
		// current window. The page is alive, in another words, you can click to
		// follow the links. Double tap will toggle between zoom overview mode and
		// the last zoom scale.
		boolean mInZoomOverview = false;

		public ZoomManager(WebView webView) {
		mWebView = webView;
		}

		public void init(float density) {
		DEFAULT_MAX_ZOOM_SCALE = 4.0f * density;
		DEFAULT_MIN_ZOOM_SCALE = 0.25f * density;
		mMaxZoomScale = DEFAULT_MAX_ZOOM_SCALE;
		mMinZoomScale = DEFAULT_MIN_ZOOM_SCALE;
		}

		private ZoomControlBase getCurrentZoomControl() {
		if (mWebView.getSettings() != null && mWebView.getSettings().supportZoom()) {
		if (mWebView.getSettings().getBuiltInZoomControls()) {
		if (mEmbeddedZoomControl == null) {
		mEmbeddedZoomControl = new ZoomControlEmbedded(this, mWebView);
		}
		return mEmbeddedZoomControl;
		} else {
		if (mExternalZoomControl == null) {
		mExternalZoomControl = new ZoomControlExternal(mWebView);
		}
		return mExternalZoomControl;
		}
		}
		return null;
		}

		public void invokeZoomPicker() {
		ZoomControlBase control = getCurrentZoomControl();
		if (control != null) {
		control.show();
		}
		}

		public void dismissZoomPicker() {
		ZoomControlBase control = getCurrentZoomControl();
		if (control != null) {
		control.hide();
		}
		}

		public boolean isZoomPickerVisible() {
		ZoomControlBase control = getCurrentZoomControl();
		return (control != null) ? control.isVisible() : false;
		}

		public void updateZoomPicker() {
		ZoomControlBase control = getCurrentZoomControl();
		if (control != null) {
		control.update();
		}
		}

		/**
		* The embedded zoom control intercepts touch events and automatically stays
		* visible. The external control needs to constantly refresh its internal
		* timer to stay visible.
		*/
		public void keepZoomPickerVisible() {
		ZoomControlBase control = getCurrentZoomControl();
		if (control != null && control == mExternalZoomControl) {
		control.show();
		}
		}

		public View getExternalZoomPicker() {
		ZoomControlBase control = getCurrentZoomControl();
		if (control != null && control == mExternalZoomControl) {
		return mExternalZoomControl.getControls();
		} else {
		return null;
		}
		}
		}