WebView.java revision 9d1abc43f5ffdb413fda5d8e39019bb40aad0b94
1/*
2 * Copyright (C) 2006 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package android.webkit;
18
19import android.app.AlertDialog;
20import android.content.Context;
21import android.content.DialogInterface;
22import android.content.Intent;
23import android.content.DialogInterface.OnCancelListener;
24import android.database.DataSetObserver;
25import android.graphics.Bitmap;
26import android.graphics.Canvas;
27import android.graphics.Color;
28import android.graphics.Picture;
29import android.graphics.Point;
30import android.graphics.Rect;
31import android.graphics.Region;
32import android.graphics.drawable.Drawable;
33import android.net.http.SslCertificate;
34import android.net.Uri;
35import android.os.Bundle;
36import android.os.Handler;
37import android.os.Message;
38import android.os.ServiceManager;
39import android.os.SystemClock;
40import android.provider.Checkin;
41import android.text.IClipboard;
42import android.text.Selection;
43import android.text.Spannable;
44import android.util.AttributeSet;
45import android.util.EventLog;
46import android.util.Log;
47import android.util.TypedValue;
48import android.view.Gravity;
49import android.view.KeyEvent;
50import android.view.LayoutInflater;
51import android.view.MotionEvent;
52import android.view.SoundEffectConstants;
53import android.view.VelocityTracker;
54import android.view.View;
55import android.view.ViewConfiguration;
56import android.view.ViewGroup;
57import android.view.ViewParent;
58import android.view.ViewTreeObserver;
59import android.view.animation.AlphaAnimation;
60import android.view.inputmethod.InputMethodManager;
61import android.webkit.WebTextView.AutoCompleteAdapter;
62import android.webkit.WebViewCore.EventHub;
63import android.widget.AbsoluteLayout;
64import android.widget.Adapter;
65import android.widget.AdapterView;
66import android.widget.ArrayAdapter;
67import android.widget.FrameLayout;
68import android.widget.ListView;
69import android.widget.Scroller;
70import android.widget.Toast;
71import android.widget.ZoomButtonsController;
72import android.widget.ZoomControls;
73import android.widget.AdapterView.OnItemClickListener;
74
75import java.io.File;
76import java.io.FileInputStream;
77import java.io.FileNotFoundException;
78import java.io.FileOutputStream;
79import java.io.IOException;
80import java.net.URLDecoder;
81import java.util.ArrayList;
82import java.util.List;
83import java.util.Map;
84
85/**
86 * <p>A View that displays web pages. This class is the basis upon which you
87 * can roll your own web browser or simply display some online content within your Activity.
88 * It uses the WebKit rendering engine to display
89 * web pages and includes methods to navigate forward and backward
90 * through a history, zoom in and out, perform text searches and more.</p>
91 * <p>To enable the built-in zoom, set
92 * {@link #getSettings() WebSettings}.{@link WebSettings#setBuiltInZoomControls(boolean)}
93 * (introduced in API version 3).
94 * <p>Note that, in order for your Activity to access the Internet and load web pages
95 * in a WebView, you must add the <var>INTERNET</var> permissions to your
96 * Android Manifest file:</p>
97 * <pre>&lt;uses-permission android:name="android.permission.INTERNET" /></pre>
98 *
99 * <p>This must be a child of the <code>&lt;manifest></code> element.</p>
100 *
101 * <h3>Basic usage</h3>
102 *
103 * <p>By default, a WebView provides no browser-like widgets, does not
104 * enable JavaScript and errors will be ignored. If your goal is only
105 * to display some HTML as a part of your UI, this is probably fine;
106 * the user won't need to interact with the web page beyond reading
107 * it, and the web page won't need to interact with the user. If you
108 * actually want a fully blown web browser, then you probably want to
109 * invoke the Browser application with your URL rather than show it
110 * with a WebView. See {@link android.content.Intent} for more information.</p>
111 *
112 * <pre class="prettyprint">
113 * WebView webview = new WebView(this);
114 * setContentView(webview);
115 *
116 * // Simplest usage: note that an exception will NOT be thrown
117 * // if there is an error loading this page (see below).
118 * webview.loadUrl("http://slashdot.org/");
119 *
120 * // Of course you can also load from any string:
121 * String summary = "&lt;html>&lt;body>You scored &lt;b>192</b> points.&lt;/body>&lt;/html>";
122 * webview.loadData(summary, "text/html", "utf-8");
123 * // ... although note that there are restrictions on what this HTML can do.
124 * // See the JavaDocs for loadData and loadDataWithBaseUrl for more info.
125 * </pre>
126 *
127 * <p>A WebView has several customization points where you can add your
128 * own behavior. These are:</p>
129 *
130 * <ul>
131 *   <li>Creating and setting a {@link android.webkit.WebChromeClient} subclass.
132 *       This class is called when something that might impact a
133 *       browser UI happens, for instance, progress updates and
134 *       JavaScript alerts are sent here.
135 *   </li>
136 *   <li>Creating and setting a {@link android.webkit.WebViewClient} subclass.
137 *       It will be called when things happen that impact the
138 *       rendering of the content, eg, errors or form submissions. You
139 *       can also intercept URL loading here.</li>
140 *   <li>Via the {@link android.webkit.WebSettings} class, which contains
141 *       miscellaneous configuration. </li>
142 *   <li>With the {@link android.webkit.WebView#addJavascriptInterface} method.
143 *       This lets you bind Java objects into the WebView so they can be
144 *       controlled from the web pages JavaScript.</li>
145 * </ul>
146 *
147 * <p>Here's a more complicated example, showing error handling,
148 *    settings, and progress notification:</p>
149 *
150 * <pre class="prettyprint">
151 * // Let's display the progress in the activity title bar, like the
152 * // browser app does.
153 * getWindow().requestFeature(Window.FEATURE_PROGRESS);
154 *
155 * webview.getSettings().setJavaScriptEnabled(true);
156 *
157 * final Activity activity = this;
158 * webview.setWebChromeClient(new WebChromeClient() {
159 *   public void onProgressChanged(WebView view, int progress) {
160 *     // Activities and WebViews measure progress with different scales.
161 *     // The progress meter will automatically disappear when we reach 100%
162 *     activity.setProgress(progress * 1000);
163 *   }
164 * });
165 * webview.setWebViewClient(new WebViewClient() {
166 *   public void onReceivedError(WebView view, int errorCode, String description, String failingUrl) {
167 *     Toast.makeText(activity, "Oh no! " + description, Toast.LENGTH_SHORT).show();
168 *   }
169 * });
170 *
171 * webview.loadUrl("http://slashdot.org/");
172 * </pre>
173 *
174 * <h3>Cookie and window management</h3>
175 *
176 * <p>For obvious security reasons, your application has its own
177 * cache, cookie store etc - it does not share the Browser
178 * applications data. Cookies are managed on a separate thread, so
179 * operations like index building don't block the UI
180 * thread. Follow the instructions in {@link android.webkit.CookieSyncManager}
181 * if you want to use cookies in your application.
182 * </p>
183 *
184 * <p>By default, requests by the HTML to open new windows are
185 * ignored. This is true whether they be opened by JavaScript or by
186 * the target attribute on a link. You can customize your
187 * WebChromeClient to provide your own behaviour for opening multiple windows,
188 * and render them in whatever manner you want.</p>
189 *
190 * <p>Standard behavior for an Activity is to be destroyed and
191 * recreated when the devices orientation is changed. This will cause
192 * the WebView to reload the current page. If you don't want that, you
193 * can set your Activity to handle the orientation and keyboardHidden
194 * changes, and then just leave the WebView alone. It'll automatically
195 * re-orient itself as appropriate.</p>
196 */
197public class WebView extends AbsoluteLayout
198        implements ViewTreeObserver.OnGlobalFocusChangeListener,
199        ViewGroup.OnHierarchyChangeListener {
200
201    // if AUTO_REDRAW_HACK is true, then the CALL key will toggle redrawing
202    // the screen all-the-time. Good for profiling our drawing code
203    static private final boolean AUTO_REDRAW_HACK = false;
204    // true means redraw the screen all-the-time. Only with AUTO_REDRAW_HACK
205    private boolean mAutoRedraw;
206
207    static final String LOGTAG = "webview";
208
209    private static class ExtendedZoomControls extends FrameLayout {
210        public ExtendedZoomControls(Context context, AttributeSet attrs) {
211            super(context, attrs);
212            LayoutInflater inflater = (LayoutInflater)
213                    context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
214            inflater.inflate(com.android.internal.R.layout.zoom_magnify, this, true);
215            mPlusMinusZoomControls = (ZoomControls) findViewById(
216                    com.android.internal.R.id.zoomControls);
217            findViewById(com.android.internal.R.id.zoomMagnify).setVisibility(
218                    View.GONE);
219        }
220
221        public void show(boolean showZoom, boolean canZoomOut) {
222            mPlusMinusZoomControls.setVisibility(
223                    showZoom ? View.VISIBLE : View.GONE);
224            fade(View.VISIBLE, 0.0f, 1.0f);
225        }
226
227        public void hide() {
228            fade(View.GONE, 1.0f, 0.0f);
229        }
230
231        private void fade(int visibility, float startAlpha, float endAlpha) {
232            AlphaAnimation anim = new AlphaAnimation(startAlpha, endAlpha);
233            anim.setDuration(500);
234            startAnimation(anim);
235            setVisibility(visibility);
236        }
237
238        public boolean hasFocus() {
239            return mPlusMinusZoomControls.hasFocus();
240        }
241
242        public void setOnZoomInClickListener(OnClickListener listener) {
243            mPlusMinusZoomControls.setOnZoomInClickListener(listener);
244        }
245
246        public void setOnZoomOutClickListener(OnClickListener listener) {
247            mPlusMinusZoomControls.setOnZoomOutClickListener(listener);
248        }
249
250        ZoomControls    mPlusMinusZoomControls;
251    }
252
253    /**
254     *  Transportation object for returning WebView across thread boundaries.
255     */
256    public class WebViewTransport {
257        private WebView mWebview;
258
259        /**
260         * Set the WebView to the transportation object.
261         * @param webview The WebView to transport.
262         */
263        public synchronized void setWebView(WebView webview) {
264            mWebview = webview;
265        }
266
267        /**
268         * Return the WebView object.
269         * @return WebView The transported WebView object.
270         */
271        public synchronized WebView getWebView() {
272            return mWebview;
273        }
274    }
275
276    // A final CallbackProxy shared by WebViewCore and BrowserFrame.
277    private final CallbackProxy mCallbackProxy;
278
279    private final WebViewDatabase mDatabase;
280
281    // SSL certificate for the main top-level page (if secure)
282    private SslCertificate mCertificate;
283
284    // Native WebView pointer that is 0 until the native object has been
285    // created.
286    private int mNativeClass;
287    // This would be final but it needs to be set to null when the WebView is
288    // destroyed.
289    private WebViewCore mWebViewCore;
290    // Handler for dispatching UI messages.
291    /* package */ final Handler mPrivateHandler = new PrivateHandler();
292    private WebTextView mWebTextView;
293    // Used to ignore changes to webkit text that arrives to the UI side after
294    // more key events.
295    private int mTextGeneration;
296
297    // Used by WebViewCore to create child views.
298    /* package */ final ViewManager mViewManager;
299
300    /**
301     * Position of the last touch event.
302     */
303    private float mLastTouchX;
304    private float mLastTouchY;
305
306    /**
307     * Time of the last touch event.
308     */
309    private long mLastTouchTime;
310
311    /**
312     * Time of the last time sending touch event to WebViewCore
313     */
314    private long mLastSentTouchTime;
315
316    /**
317     * The minimum elapsed time before sending another ACTION_MOVE event to
318     * WebViewCore. This really should be tuned for each type of the devices.
319     * For example in Google Map api test case, it takes Dream device at least
320     * 150ms to do a full cycle in the WebViewCore by processing a touch event,
321     * triggering the layout and drawing the picture. While the same process
322     * takes 60+ms on the current high speed device. If we make
323     * TOUCH_SENT_INTERVAL too small, there will be multiple touch events sent
324     * to WebViewCore queue and the real layout and draw events will be pushed
325     * to further, which slows down the refresh rate. Choose 50 to favor the
326     * current high speed devices. For Dream like devices, 100 is a better
327     * choice. Maybe make this in the buildspec later.
328     */
329    private static final int TOUCH_SENT_INTERVAL = 50;
330
331    /**
332     * Helper class to get velocity for fling
333     */
334    VelocityTracker mVelocityTracker;
335    private int mMaximumFling;
336    private float mLastVelocity;
337    private float mLastVelX;
338    private float mLastVelY;
339
340    /**
341     * Touch mode
342     */
343    private int mTouchMode = TOUCH_DONE_MODE;
344    private static final int TOUCH_INIT_MODE = 1;
345    private static final int TOUCH_DRAG_START_MODE = 2;
346    private static final int TOUCH_DRAG_MODE = 3;
347    private static final int TOUCH_SHORTPRESS_START_MODE = 4;
348    private static final int TOUCH_SHORTPRESS_MODE = 5;
349    private static final int TOUCH_DOUBLE_TAP_MODE = 6;
350    private static final int TOUCH_DONE_MODE = 7;
351    private static final int TOUCH_SELECT_MODE = 8;
352
353    // Whether to forward the touch events to WebCore
354    private boolean mForwardTouchEvents = false;
355
356    // Whether to prevent drag during touch. The initial value depends on
357    // mForwardTouchEvents. If WebCore wants touch events, we assume it will
358    // take control of touch events unless it says no for touch down event.
359    private static final int PREVENT_DRAG_NO = 0;
360    private static final int PREVENT_DRAG_MAYBE_YES = 1;
361    private static final int PREVENT_DRAG_YES = 2;
362    private int mPreventDrag = PREVENT_DRAG_NO;
363
364    // To keep track of whether the current drag was initiated by a WebTextView,
365    // so that we know not to hide the cursor
366    boolean mDragFromTextInput;
367
368    // Whether or not to draw the cursor ring.
369    private boolean mDrawCursorRing = true;
370
371    // true if onPause has been called (and not onResume)
372    private boolean mIsPaused;
373
374    /**
375     * Customizable constant
376     */
377    // pre-computed square of ViewConfiguration.getScaledTouchSlop()
378    private int mTouchSlopSquare;
379    // pre-computed square of ViewConfiguration.getScaledDoubleTapSlop()
380    private int mDoubleTapSlopSquare;
381    // pre-computed density adjusted navigation slop
382    private int mNavSlop;
383    // This should be ViewConfiguration.getTapTimeout()
384    // But system time out is 100ms, which is too short for the browser.
385    // In the browser, if it switches out of tap too soon, jump tap won't work.
386    private static final int TAP_TIMEOUT = 200;
387    // This should be ViewConfiguration.getLongPressTimeout()
388    // But system time out is 500ms, which is too short for the browser.
389    // With a short timeout, it's difficult to treat trigger a short press.
390    private static final int LONG_PRESS_TIMEOUT = 1000;
391    // needed to avoid flinging after a pause of no movement
392    private static final int MIN_FLING_TIME = 250;
393    // The time that the Zoom Controls are visible before fading away
394    private static final long ZOOM_CONTROLS_TIMEOUT =
395            ViewConfiguration.getZoomControlsTimeout();
396    // The amount of content to overlap between two screens when going through
397    // pages with the space bar, in pixels.
398    private static final int PAGE_SCROLL_OVERLAP = 24;
399
400    /**
401     * These prevent calling requestLayout if either dimension is fixed. This
402     * depends on the layout parameters and the measure specs.
403     */
404    boolean mWidthCanMeasure;
405    boolean mHeightCanMeasure;
406
407    // Remember the last dimensions we sent to the native side so we can avoid
408    // sending the same dimensions more than once.
409    int mLastWidthSent;
410    int mLastHeightSent;
411
412    private int mContentWidth;   // cache of value from WebViewCore
413    private int mContentHeight;  // cache of value from WebViewCore
414
415    // Need to have the separate control for horizontal and vertical scrollbar
416    // style than the View's single scrollbar style
417    private boolean mOverlayHorizontalScrollbar = true;
418    private boolean mOverlayVerticalScrollbar = false;
419
420    // our standard speed. this way small distances will be traversed in less
421    // time than large distances, but we cap the duration, so that very large
422    // distances won't take too long to get there.
423    private static final int STD_SPEED = 480;  // pixels per second
424    // time for the longest scroll animation
425    private static final int MAX_DURATION = 750;   // milliseconds
426    private static final int SLIDE_TITLE_DURATION = 500;   // milliseconds
427    private Scroller mScroller;
428
429    private boolean mWrapContent;
430
431    /**
432     * Private message ids
433     */
434    private static final int REMEMBER_PASSWORD          = 1;
435    private static final int NEVER_REMEMBER_PASSWORD    = 2;
436    private static final int SWITCH_TO_SHORTPRESS       = 3;
437    private static final int SWITCH_TO_LONGPRESS        = 4;
438    private static final int RELEASE_SINGLE_TAP         = 5;
439    private static final int REQUEST_FORM_DATA          = 6;
440    private static final int RESUME_WEBCORE_UPDATE      = 7;
441
442    //! arg1=x, arg2=y
443    static final int SCROLL_TO_MSG_ID                   = 10;
444    static final int SCROLL_BY_MSG_ID                   = 11;
445    //! arg1=x, arg2=y
446    static final int SPAWN_SCROLL_TO_MSG_ID             = 12;
447    //! arg1=x, arg2=y
448    static final int SYNC_SCROLL_TO_MSG_ID              = 13;
449    static final int NEW_PICTURE_MSG_ID                 = 14;
450    static final int UPDATE_TEXT_ENTRY_MSG_ID           = 15;
451    static final int WEBCORE_INITIALIZED_MSG_ID         = 16;
452    static final int UPDATE_TEXTFIELD_TEXT_MSG_ID       = 17;
453    static final int MOVE_OUT_OF_PLUGIN                 = 19;
454    static final int CLEAR_TEXT_ENTRY                   = 20;
455    static final int UPDATE_TEXT_SELECTION_MSG_ID       = 21;
456    static final int UPDATE_CLIPBOARD                   = 22;
457    static final int LONG_PRESS_CENTER                  = 23;
458    static final int PREVENT_TOUCH_ID                   = 24;
459    static final int WEBCORE_NEED_TOUCH_EVENTS          = 25;
460    // obj=Rect in doc coordinates
461    static final int INVAL_RECT_MSG_ID                  = 26;
462    static final int REQUEST_KEYBOARD                   = 27;
463
464    static final String[] HandlerDebugString = {
465        "REMEMBER_PASSWORD", //              = 1;
466        "NEVER_REMEMBER_PASSWORD", //        = 2;
467        "SWITCH_TO_SHORTPRESS", //           = 3;
468        "SWITCH_TO_LONGPRESS", //            = 4;
469        "RELEASE_SINGLE_TAP", //             = 5;
470        "REQUEST_FORM_DATA", //              = 6;
471        "SWITCH_TO_CLICK", //                = 7;
472        "RESUME_WEBCORE_UPDATE", //          = 8;
473        "9",
474        "SCROLL_TO_MSG_ID", //               = 10;
475        "SCROLL_BY_MSG_ID", //               = 11;
476        "SPAWN_SCROLL_TO_MSG_ID", //         = 12;
477        "SYNC_SCROLL_TO_MSG_ID", //          = 13;
478        "NEW_PICTURE_MSG_ID", //             = 14;
479        "UPDATE_TEXT_ENTRY_MSG_ID", //       = 15;
480        "WEBCORE_INITIALIZED_MSG_ID", //     = 16;
481        "UPDATE_TEXTFIELD_TEXT_MSG_ID", //   = 17;
482        "18", //        = 18;
483        "MOVE_OUT_OF_PLUGIN", //             = 19;
484        "CLEAR_TEXT_ENTRY", //               = 20;
485        "UPDATE_TEXT_SELECTION_MSG_ID", //   = 21;
486        "UPDATE_CLIPBOARD", //               = 22;
487        "LONG_PRESS_CENTER", //              = 23;
488        "PREVENT_TOUCH_ID", //               = 24;
489        "WEBCORE_NEED_TOUCH_EVENTS", //      = 25;
490        "INVAL_RECT_MSG_ID", //              = 26;
491        "REQUEST_KEYBOARD" //                = 27;
492    };
493
494    // default scale limit. Depending on the display density
495    private static float DEFAULT_MAX_ZOOM_SCALE;
496    private static float DEFAULT_MIN_ZOOM_SCALE;
497    // scale limit, which can be set through viewport meta tag in the web page
498    private float mMaxZoomScale;
499    private float mMinZoomScale;
500    private boolean mMinZoomScaleFixed = true;
501
502    // initial scale in percent. 0 means using default.
503    private int mInitialScale = 0;
504
505    // while in the zoom overview mode, the page's width is fully fit to the
506    // current window. The page is alive, in another words, you can click to
507    // follow the links. Double tap will toggle between zoom overview mode and
508    // the last zoom scale.
509    boolean mInZoomOverview = false;
510
511    // ideally mZoomOverviewWidth should be mContentWidth. But sites like espn,
512    // engadget always have wider mContentWidth no matter what viewport size is.
513    int mZoomOverviewWidth = WebViewCore.DEFAULT_VIEWPORT_WIDTH;
514    float mLastScale;
515
516    // default scale. Depending on the display density.
517    static int DEFAULT_SCALE_PERCENT;
518    private float mDefaultScale;
519
520    // set to true temporarily while the zoom control is being dragged
521    private boolean mPreviewZoomOnly = false;
522
523    // computed scale and inverse, from mZoomWidth.
524    private float mActualScale;
525    private float mInvActualScale;
526    // if this is non-zero, it is used on drawing rather than mActualScale
527    private float mZoomScale;
528    private float mInvInitialZoomScale;
529    private float mInvFinalZoomScale;
530    private int mInitialScrollX;
531    private int mInitialScrollY;
532    private long mZoomStart;
533    private static final int ZOOM_ANIMATION_LENGTH = 500;
534
535    private boolean mUserScroll = false;
536
537    private int mSnapScrollMode = SNAP_NONE;
538    private static final int SNAP_NONE = 1;
539    private static final int SNAP_X = 2;
540    private static final int SNAP_Y = 3;
541    private static final int SNAP_X_LOCK = 4;
542    private static final int SNAP_Y_LOCK = 5;
543    private boolean mSnapPositive;
544
545    // Used to match key downs and key ups
546    private boolean mGotKeyDown;
547
548    /* package */ static boolean mLogEvent = true;
549    private static final int EVENT_LOG_ZOOM_LEVEL_CHANGE = 70101;
550    private static final int EVENT_LOG_DOUBLE_TAP_DURATION = 70102;
551
552    // for event log
553    private long mLastTouchUpTime = 0;
554
555    /**
556     * URI scheme for telephone number
557     */
558    public static final String SCHEME_TEL = "tel:";
559    /**
560     * URI scheme for email address
561     */
562    public static final String SCHEME_MAILTO = "mailto:";
563    /**
564     * URI scheme for map address
565     */
566    public static final String SCHEME_GEO = "geo:0,0?q=";
567
568    private int mBackgroundColor = Color.WHITE;
569
570    // Used to notify listeners of a new picture.
571    private PictureListener mPictureListener;
572    /**
573     * Interface to listen for new pictures as they change.
574     */
575    public interface PictureListener {
576        /**
577         * Notify the listener that the picture has changed.
578         * @param view The WebView that owns the picture.
579         * @param picture The new picture.
580         */
581        public void onNewPicture(WebView view, Picture picture);
582    }
583
584    // FIXME: Want to make this public, but need to change the API file.
585    public /*static*/ class HitTestResult {
586        /**
587         * Default HitTestResult, where the target is unknown
588         */
589        public static final int UNKNOWN_TYPE = 0;
590        /**
591         * HitTestResult for hitting a HTML::a tag
592         */
593        public static final int ANCHOR_TYPE = 1;
594        /**
595         * HitTestResult for hitting a phone number
596         */
597        public static final int PHONE_TYPE = 2;
598        /**
599         * HitTestResult for hitting a map address
600         */
601        public static final int GEO_TYPE = 3;
602        /**
603         * HitTestResult for hitting an email address
604         */
605        public static final int EMAIL_TYPE = 4;
606        /**
607         * HitTestResult for hitting an HTML::img tag
608         */
609        public static final int IMAGE_TYPE = 5;
610        /**
611         * HitTestResult for hitting a HTML::a tag which contains HTML::img
612         */
613        public static final int IMAGE_ANCHOR_TYPE = 6;
614        /**
615         * HitTestResult for hitting a HTML::a tag with src=http
616         */
617        public static final int SRC_ANCHOR_TYPE = 7;
618        /**
619         * HitTestResult for hitting a HTML::a tag with src=http + HTML::img
620         */
621        public static final int SRC_IMAGE_ANCHOR_TYPE = 8;
622        /**
623         * HitTestResult for hitting an edit text area
624         */
625        public static final int EDIT_TEXT_TYPE = 9;
626
627        private int mType;
628        private String mExtra;
629
630        HitTestResult() {
631            mType = UNKNOWN_TYPE;
632        }
633
634        private void setType(int type) {
635            mType = type;
636        }
637
638        private void setExtra(String extra) {
639            mExtra = extra;
640        }
641
642        public int getType() {
643            return mType;
644        }
645
646        public String getExtra() {
647            return mExtra;
648        }
649    }
650
651    // The View containing the zoom controls
652    private ExtendedZoomControls mZoomControls;
653    private Runnable mZoomControlRunnable;
654
655    private ZoomButtonsController mZoomButtonsController;
656
657    // These keep track of the center point of the zoom.  They are used to
658    // determine the point around which we should zoom.
659    private float mZoomCenterX;
660    private float mZoomCenterY;
661
662    private ZoomButtonsController.OnZoomListener mZoomListener =
663            new ZoomButtonsController.OnZoomListener() {
664
665        public void onVisibilityChanged(boolean visible) {
666            if (visible) {
667                switchOutDrawHistory();
668                updateZoomButtonsEnabled();
669            }
670        }
671
672        public void onZoom(boolean zoomIn) {
673            if (zoomIn) {
674                zoomIn();
675            } else {
676                zoomOut();
677            }
678
679            updateZoomButtonsEnabled();
680        }
681    };
682
683    /**
684     * Construct a new WebView with a Context object.
685     * @param context A Context object used to access application assets.
686     */
687    public WebView(Context context) {
688        this(context, null);
689    }
690
691    /**
692     * Construct a new WebView with layout parameters.
693     * @param context A Context object used to access application assets.
694     * @param attrs An AttributeSet passed to our parent.
695     */
696    public WebView(Context context, AttributeSet attrs) {
697        this(context, attrs, com.android.internal.R.attr.webViewStyle);
698    }
699
700    /**
701     * Construct a new WebView with layout parameters and a default style.
702     * @param context A Context object used to access application assets.
703     * @param attrs An AttributeSet passed to our parent.
704     * @param defStyle The default style resource ID.
705     */
706    public WebView(Context context, AttributeSet attrs, int defStyle) {
707        this(context, attrs, defStyle, null);
708    }
709
710    /**
711     * Construct a new WebView with layout parameters, a default style and a set
712     * of custom Javscript interfaces to be added to the WebView at initialization
713     * time. This guraratees that these interfaces will be available when the JS
714     * context is initialized.
715     * @param context A Context object used to access application assets.
716     * @param attrs An AttributeSet passed to our parent.
717     * @param defStyle The default style resource ID.
718     * @param javascriptInterfaces is a Map of intareface names, as keys, and
719     * object implementing those interfaces, as values.
720     * @hide pending API council approval.
721     */
722    protected WebView(Context context, AttributeSet attrs, int defStyle,
723            Map<String, Object> javascriptInterfaces) {
724        super(context, attrs, defStyle);
725        init();
726
727        mCallbackProxy = new CallbackProxy(context, this);
728        mWebViewCore = new WebViewCore(context, this, mCallbackProxy, javascriptInterfaces);
729        mDatabase = WebViewDatabase.getInstance(context);
730        mScroller = new Scroller(context);
731
732        mViewManager = new ViewManager(this);
733
734        mZoomButtonsController = new ZoomButtonsController(this);
735        mZoomButtonsController.setOnZoomListener(mZoomListener);
736        // ZoomButtonsController positions the buttons at the bottom, but in
737        // the middle.  Change their layout parameters so they appear on the
738        // right.
739        View controls = mZoomButtonsController.getZoomControls();
740        ViewGroup.LayoutParams params = controls.getLayoutParams();
741        if (params instanceof FrameLayout.LayoutParams) {
742            FrameLayout.LayoutParams frameParams = (FrameLayout.LayoutParams)
743                    params;
744            frameParams.gravity = Gravity.RIGHT;
745        }
746    }
747
748    private void updateZoomButtonsEnabled() {
749        boolean canZoomIn = mActualScale < mMaxZoomScale;
750        boolean canZoomOut = mActualScale > mMinZoomScale && !mInZoomOverview;
751        if (!canZoomIn && !canZoomOut) {
752            // Hide the zoom in and out buttons, as well as the fit to page
753            // button, if the page cannot zoom
754            mZoomButtonsController.getZoomControls().setVisibility(View.GONE);
755        } else {
756            // Bring back the hidden zoom controls.
757            mZoomButtonsController.getZoomControls()
758                    .setVisibility(View.VISIBLE);
759            // Set each one individually, as a page may be able to zoom in
760            // or out.
761            mZoomButtonsController.setZoomInEnabled(canZoomIn);
762            mZoomButtonsController.setZoomOutEnabled(canZoomOut);
763        }
764    }
765
766    private void init() {
767        setWillNotDraw(false);
768        setFocusable(true);
769        setFocusableInTouchMode(true);
770        setClickable(true);
771        setLongClickable(true);
772
773        final ViewConfiguration configuration = ViewConfiguration.get(getContext());
774        int slop = configuration.getScaledTouchSlop();
775        mTouchSlopSquare = slop * slop;
776        mMinLockSnapReverseDistance = slop;
777        slop = configuration.getScaledDoubleTapSlop();
778        mDoubleTapSlopSquare = slop * slop;
779        final float density = getContext().getResources().getDisplayMetrics().density;
780        // use one line height, 16 based on our current default font, for how
781        // far we allow a touch be away from the edge of a link
782        mNavSlop = (int) (16 * density);
783        // density adjusted scale factors
784        DEFAULT_SCALE_PERCENT = (int) (100 * density);
785        mDefaultScale = density;
786        mActualScale = density;
787        mInvActualScale = 1 / density;
788        DEFAULT_MAX_ZOOM_SCALE = 4.0f * density;
789        DEFAULT_MIN_ZOOM_SCALE = 0.25f * density;
790        mMaxZoomScale = DEFAULT_MAX_ZOOM_SCALE;
791        mMinZoomScale = DEFAULT_MIN_ZOOM_SCALE;
792        mMaximumFling = configuration.getScaledMaximumFlingVelocity();
793    }
794
795    /* package */void updateDefaultZoomDensity(int zoomDensity) {
796        final float density = getContext().getResources().getDisplayMetrics().density
797                * 100 / zoomDensity;
798        if (Math.abs(density - mDefaultScale) > 0.01) {
799            float scaleFactor = density / mDefaultScale;
800            // adjust the limits
801            mNavSlop = (int) (16 * density);
802            DEFAULT_SCALE_PERCENT = (int) (100 * density);
803            DEFAULT_MAX_ZOOM_SCALE = 4.0f * density;
804            DEFAULT_MIN_ZOOM_SCALE = 0.25f * density;
805            mDefaultScale = density;
806            mMaxZoomScale *= scaleFactor;
807            mMinZoomScale *= scaleFactor;
808            setNewZoomScale(mActualScale * scaleFactor, false);
809        }
810    }
811
812    /* package */ boolean onSavePassword(String schemePlusHost, String username,
813            String password, final Message resumeMsg) {
814       boolean rVal = false;
815       if (resumeMsg == null) {
816           // null resumeMsg implies saving password silently
817           mDatabase.setUsernamePassword(schemePlusHost, username, password);
818       } else {
819            final Message remember = mPrivateHandler.obtainMessage(
820                    REMEMBER_PASSWORD);
821            remember.getData().putString("host", schemePlusHost);
822            remember.getData().putString("username", username);
823            remember.getData().putString("password", password);
824            remember.obj = resumeMsg;
825
826            final Message neverRemember = mPrivateHandler.obtainMessage(
827                    NEVER_REMEMBER_PASSWORD);
828            neverRemember.getData().putString("host", schemePlusHost);
829            neverRemember.getData().putString("username", username);
830            neverRemember.getData().putString("password", password);
831            neverRemember.obj = resumeMsg;
832
833            new AlertDialog.Builder(getContext())
834                    .setTitle(com.android.internal.R.string.save_password_label)
835                    .setMessage(com.android.internal.R.string.save_password_message)
836                    .setPositiveButton(com.android.internal.R.string.save_password_notnow,
837                    new DialogInterface.OnClickListener() {
838                        public void onClick(DialogInterface dialog, int which) {
839                            resumeMsg.sendToTarget();
840                        }
841                    })
842                    .setNeutralButton(com.android.internal.R.string.save_password_remember,
843                    new DialogInterface.OnClickListener() {
844                        public void onClick(DialogInterface dialog, int which) {
845                            remember.sendToTarget();
846                        }
847                    })
848                    .setNegativeButton(com.android.internal.R.string.save_password_never,
849                    new DialogInterface.OnClickListener() {
850                        public void onClick(DialogInterface dialog, int which) {
851                            neverRemember.sendToTarget();
852                        }
853                    })
854                    .setOnCancelListener(new OnCancelListener() {
855                        public void onCancel(DialogInterface dialog) {
856                            resumeMsg.sendToTarget();
857                        }
858                    }).show();
859            // Return true so that WebViewCore will pause while the dialog is
860            // up.
861            rVal = true;
862        }
863       return rVal;
864    }
865
866    @Override
867    public void setScrollBarStyle(int style) {
868        if (style == View.SCROLLBARS_INSIDE_INSET
869                || style == View.SCROLLBARS_OUTSIDE_INSET) {
870            mOverlayHorizontalScrollbar = mOverlayVerticalScrollbar = false;
871        } else {
872            mOverlayHorizontalScrollbar = mOverlayVerticalScrollbar = true;
873        }
874        super.setScrollBarStyle(style);
875    }
876
877    /**
878     * Specify whether the horizontal scrollbar has overlay style.
879     * @param overlay TRUE if horizontal scrollbar should have overlay style.
880     */
881    public void setHorizontalScrollbarOverlay(boolean overlay) {
882        mOverlayHorizontalScrollbar = overlay;
883    }
884
885    /**
886     * Specify whether the vertical scrollbar has overlay style.
887     * @param overlay TRUE if vertical scrollbar should have overlay style.
888     */
889    public void setVerticalScrollbarOverlay(boolean overlay) {
890        mOverlayVerticalScrollbar = overlay;
891    }
892
893    /**
894     * Return whether horizontal scrollbar has overlay style
895     * @return TRUE if horizontal scrollbar has overlay style.
896     */
897    public boolean overlayHorizontalScrollbar() {
898        return mOverlayHorizontalScrollbar;
899    }
900
901    /**
902     * Return whether vertical scrollbar has overlay style
903     * @return TRUE if vertical scrollbar has overlay style.
904     */
905    public boolean overlayVerticalScrollbar() {
906        return mOverlayVerticalScrollbar;
907    }
908
909    /*
910     * Return the width of the view where the content of WebView should render
911     * to.
912     * Note: this can be called from WebCoreThread.
913     */
914    /* package */ int getViewWidth() {
915        if (!isVerticalScrollBarEnabled() || mOverlayVerticalScrollbar) {
916            return getWidth();
917        } else {
918            return getWidth() - getVerticalScrollbarWidth();
919        }
920    }
921
922    /*
923     * returns the height of the titlebarview (if any). Does not care about
924     * scrolling
925     */
926    private int getTitleHeight() {
927        return mTitleBar != null ? mTitleBar.getHeight() : 0;
928    }
929
930    /*
931     * Return the amount of the titlebarview (if any) that is visible
932     */
933    private int getVisibleTitleHeight() {
934        return Math.max(getTitleHeight() - mScrollY, 0);
935    }
936
937    /*
938     * Return the height of the view where the content of WebView should render
939     * to.  Note that this excludes mTitleBar, if there is one.
940     * Note: this can be called from WebCoreThread.
941     */
942    /* package */ int getViewHeight() {
943        return getViewHeightWithTitle() - getVisibleTitleHeight();
944    }
945
946    private int getViewHeightWithTitle() {
947        int height = getHeight();
948        if (isHorizontalScrollBarEnabled() && !mOverlayHorizontalScrollbar) {
949            height -= getHorizontalScrollbarHeight();
950        }
951        return height;
952    }
953
954    /**
955     * @return The SSL certificate for the main top-level page or null if
956     * there is no certificate (the site is not secure).
957     */
958    public SslCertificate getCertificate() {
959        return mCertificate;
960    }
961
962    /**
963     * Sets the SSL certificate for the main top-level page.
964     */
965    public void setCertificate(SslCertificate certificate) {
966        // here, the certificate can be null (if the site is not secure)
967        mCertificate = certificate;
968    }
969
970    //-------------------------------------------------------------------------
971    // Methods called by activity
972    //-------------------------------------------------------------------------
973
974    /**
975     * Save the username and password for a particular host in the WebView's
976     * internal database.
977     * @param host The host that required the credentials.
978     * @param username The username for the given host.
979     * @param password The password for the given host.
980     */
981    public void savePassword(String host, String username, String password) {
982        mDatabase.setUsernamePassword(host, username, password);
983    }
984
985    /**
986     * Set the HTTP authentication credentials for a given host and realm.
987     *
988     * @param host The host for the credentials.
989     * @param realm The realm for the credentials.
990     * @param username The username for the password. If it is null, it means
991     *                 password can't be saved.
992     * @param password The password
993     */
994    public void setHttpAuthUsernamePassword(String host, String realm,
995            String username, String password) {
996        mDatabase.setHttpAuthUsernamePassword(host, realm, username, password);
997    }
998
999    /**
1000     * Retrieve the HTTP authentication username and password for a given
1001     * host & realm pair
1002     *
1003     * @param host The host for which the credentials apply.
1004     * @param realm The realm for which the credentials apply.
1005     * @return String[] if found, String[0] is username, which can be null and
1006     *         String[1] is password. Return null if it can't find anything.
1007     */
1008    public String[] getHttpAuthUsernamePassword(String host, String realm) {
1009        return mDatabase.getHttpAuthUsernamePassword(host, realm);
1010    }
1011
1012    /**
1013     * Destroy the internal state of the WebView. This method should be called
1014     * after the WebView has been removed from the view system. No other
1015     * methods may be called on a WebView after destroy.
1016     */
1017    public void destroy() {
1018        clearTextEntry();
1019        if (mWebViewCore != null) {
1020            // Set the handlers to null before destroying WebViewCore so no
1021            // more messages will be posted.
1022            mCallbackProxy.setWebViewClient(null);
1023            mCallbackProxy.setWebChromeClient(null);
1024            // Tell WebViewCore to destroy itself
1025            WebViewCore webViewCore = mWebViewCore;
1026            mWebViewCore = null; // prevent using partial webViewCore
1027            webViewCore.destroy();
1028            // Remove any pending messages that might not be serviced yet.
1029            mPrivateHandler.removeCallbacksAndMessages(null);
1030            mCallbackProxy.removeCallbacksAndMessages(null);
1031            // Wake up the WebCore thread just in case it is waiting for a
1032            // javascript dialog.
1033            synchronized (mCallbackProxy) {
1034                mCallbackProxy.notify();
1035            }
1036        }
1037        if (mNativeClass != 0) {
1038            nativeDestroy();
1039            mNativeClass = 0;
1040        }
1041    }
1042
1043    /**
1044     * Enables platform notifications of data state and proxy changes.
1045     */
1046    public static void enablePlatformNotifications() {
1047        Network.enablePlatformNotifications();
1048    }
1049
1050    /**
1051     * If platform notifications are enabled, this should be called
1052     * from the Activity's onPause() or onStop().
1053     */
1054    public static void disablePlatformNotifications() {
1055        Network.disablePlatformNotifications();
1056    }
1057
1058    /**
1059     * Sets JavaScript engine flags.
1060     *
1061     * @param flags JS engine flags in a String
1062     *
1063     * @hide pending API solidification
1064     */
1065    public void setJsFlags(String flags) {
1066        mWebViewCore.sendMessage(EventHub.SET_JS_FLAGS, flags);
1067    }
1068
1069    /**
1070     * Inform WebView of the network state. This is used to set
1071     * the javascript property window.navigator.isOnline and
1072     * generates the online/offline event as specified in HTML5, sec. 5.7.7
1073     * @param networkUp boolean indicating if network is available
1074     */
1075    public void setNetworkAvailable(boolean networkUp) {
1076        mWebViewCore.sendMessage(EventHub.SET_NETWORK_STATE,
1077                networkUp ? 1 : 0, 0);
1078    }
1079
1080    /**
1081     * Save the state of this WebView used in
1082     * {@link android.app.Activity#onSaveInstanceState}. Please note that this
1083     * method no longer stores the display data for this WebView. The previous
1084     * behavior could potentially leak files if {@link #restoreState} was never
1085     * called. See {@link #savePicture} and {@link #restorePicture} for saving
1086     * and restoring the display data.
1087     * @param outState The Bundle to store the WebView state.
1088     * @return The same copy of the back/forward list used to save the state. If
1089     *         saveState fails, the returned list will be null.
1090     * @see #savePicture
1091     * @see #restorePicture
1092     */
1093    public WebBackForwardList saveState(Bundle outState) {
1094        if (outState == null) {
1095            return null;
1096        }
1097        // We grab a copy of the back/forward list because a client of WebView
1098        // may have invalidated the history list by calling clearHistory.
1099        WebBackForwardList list = copyBackForwardList();
1100        final int currentIndex = list.getCurrentIndex();
1101        final int size = list.getSize();
1102        // We should fail saving the state if the list is empty or the index is
1103        // not in a valid range.
1104        if (currentIndex < 0 || currentIndex >= size || size == 0) {
1105            return null;
1106        }
1107        outState.putInt("index", currentIndex);
1108        // FIXME: This should just be a byte[][] instead of ArrayList but
1109        // Parcel.java does not have the code to handle multi-dimensional
1110        // arrays.
1111        ArrayList<byte[]> history = new ArrayList<byte[]>(size);
1112        for (int i = 0; i < size; i++) {
1113            WebHistoryItem item = list.getItemAtIndex(i);
1114            if (null == item) {
1115                // FIXME: this shouldn't happen
1116                // need to determine how item got set to null
1117                Log.w(LOGTAG, "saveState: Unexpected null history item.");
1118                return null;
1119            }
1120            byte[] data = item.getFlattenedData();
1121            if (data == null) {
1122                // It would be very odd to not have any data for a given history
1123                // item. And we will fail to rebuild the history list without
1124                // flattened data.
1125                return null;
1126            }
1127            history.add(data);
1128        }
1129        outState.putSerializable("history", history);
1130        if (mCertificate != null) {
1131            outState.putBundle("certificate",
1132                               SslCertificate.saveState(mCertificate));
1133        }
1134        return list;
1135    }
1136
1137    /**
1138     * Save the current display data to the Bundle given. Used in conjunction
1139     * with {@link #saveState}.
1140     * @param b A Bundle to store the display data.
1141     * @param dest The file to store the serialized picture data. Will be
1142     *             overwritten with this WebView's picture data.
1143     * @return True if the picture was successfully saved.
1144     */
1145    public boolean savePicture(Bundle b, File dest) {
1146        if (dest == null || b == null) {
1147            return false;
1148        }
1149        final Picture p = capturePicture();
1150        try {
1151            final FileOutputStream out = new FileOutputStream(dest);
1152            p.writeToStream(out);
1153            out.close();
1154        } catch (FileNotFoundException e){
1155            e.printStackTrace();
1156        } catch (IOException e) {
1157            e.printStackTrace();
1158        } catch (RuntimeException e) {
1159            e.printStackTrace();
1160        }
1161        if (dest.length() > 0) {
1162            b.putInt("scrollX", mScrollX);
1163            b.putInt("scrollY", mScrollY);
1164            b.putFloat("scale", mActualScale);
1165            if (mInZoomOverview) {
1166                b.putFloat("lastScale", mLastScale);
1167            }
1168            return true;
1169        }
1170        return false;
1171    }
1172
1173    /**
1174     * Restore the display data that was save in {@link #savePicture}. Used in
1175     * conjunction with {@link #restoreState}.
1176     * @param b A Bundle containing the saved display data.
1177     * @param src The file where the picture data was stored.
1178     * @return True if the picture was successfully restored.
1179     */
1180    public boolean restorePicture(Bundle b, File src) {
1181        if (src == null || b == null) {
1182            return false;
1183        }
1184        if (src.exists()) {
1185            Picture p = null;
1186            try {
1187                final FileInputStream in = new FileInputStream(src);
1188                p = Picture.createFromStream(in);
1189                in.close();
1190            } catch (FileNotFoundException e){
1191                e.printStackTrace();
1192            } catch (RuntimeException e) {
1193                e.printStackTrace();
1194            } catch (IOException e) {
1195                e.printStackTrace();
1196            }
1197            if (p != null) {
1198                int sx = b.getInt("scrollX", 0);
1199                int sy = b.getInt("scrollY", 0);
1200                float scale = b.getFloat("scale", 1.0f);
1201                mDrawHistory = true;
1202                mHistoryPicture = p;
1203                mScrollX = sx;
1204                mScrollY = sy;
1205                mHistoryWidth = Math.round(p.getWidth() * scale);
1206                mHistoryHeight = Math.round(p.getHeight() * scale);
1207                // as getWidth() / getHeight() of the view are not
1208                // available yet, set up mActualScale, so that when
1209                // onSizeChanged() is called, the rest will be set
1210                // correctly
1211                mActualScale = scale;
1212                float lastScale = b.getFloat("lastScale", -1.0f);
1213                if (lastScale > 0) {
1214                    mInZoomOverview = true;
1215                    mLastScale = lastScale;
1216                } else {
1217                    mInZoomOverview = false;
1218                }
1219                invalidate();
1220                return true;
1221            }
1222        }
1223        return false;
1224    }
1225
1226    /**
1227     * Restore the state of this WebView from the given map used in
1228     * {@link android.app.Activity#onRestoreInstanceState}. This method should
1229     * be called to restore the state of the WebView before using the object. If
1230     * it is called after the WebView has had a chance to build state (load
1231     * pages, create a back/forward list, etc.) there may be undesirable
1232     * side-effects. Please note that this method no longer restores the
1233     * display data for this WebView. See {@link #savePicture} and {@link
1234     * #restorePicture} for saving and restoring the display data.
1235     * @param inState The incoming Bundle of state.
1236     * @return The restored back/forward list or null if restoreState failed.
1237     * @see #savePicture
1238     * @see #restorePicture
1239     */
1240    public WebBackForwardList restoreState(Bundle inState) {
1241        WebBackForwardList returnList = null;
1242        if (inState == null) {
1243            return returnList;
1244        }
1245        if (inState.containsKey("index") && inState.containsKey("history")) {
1246            mCertificate = SslCertificate.restoreState(
1247                inState.getBundle("certificate"));
1248
1249            final WebBackForwardList list = mCallbackProxy.getBackForwardList();
1250            final int index = inState.getInt("index");
1251            // We can't use a clone of the list because we need to modify the
1252            // shared copy, so synchronize instead to prevent concurrent
1253            // modifications.
1254            synchronized (list) {
1255                final List<byte[]> history =
1256                        (List<byte[]>) inState.getSerializable("history");
1257                final int size = history.size();
1258                // Check the index bounds so we don't crash in native code while
1259                // restoring the history index.
1260                if (index < 0 || index >= size) {
1261                    return null;
1262                }
1263                for (int i = 0; i < size; i++) {
1264                    byte[] data = history.remove(0);
1265                    if (data == null) {
1266                        // If we somehow have null data, we cannot reconstruct
1267                        // the item and thus our history list cannot be rebuilt.
1268                        return null;
1269                    }
1270                    WebHistoryItem item = new WebHistoryItem(data);
1271                    list.addHistoryItem(item);
1272                }
1273                // Grab the most recent copy to return to the caller.
1274                returnList = copyBackForwardList();
1275                // Update the copy to have the correct index.
1276                returnList.setCurrentIndex(index);
1277            }
1278            // Remove all pending messages because we are restoring previous
1279            // state.
1280            mWebViewCore.removeMessages();
1281            // Send a restore state message.
1282            mWebViewCore.sendMessage(EventHub.RESTORE_STATE, index);
1283        }
1284        return returnList;
1285    }
1286
1287    /**
1288     * Load the given url.
1289     * @param url The url of the resource to load.
1290     */
1291    public void loadUrl(String url) {
1292        if (url == null) {
1293            return;
1294        }
1295        switchOutDrawHistory();
1296        mWebViewCore.sendMessage(EventHub.LOAD_URL, url);
1297        clearTextEntry();
1298    }
1299
1300    /**
1301     * Load the url with postData using "POST" method into the WebView. If url
1302     * is not a network url, it will be loaded with {link
1303     * {@link #loadUrl(String)} instead.
1304     *
1305     * @param url The url of the resource to load.
1306     * @param postData The data will be passed to "POST" request.
1307     */
1308    public void postUrl(String url, byte[] postData) {
1309        if (URLUtil.isNetworkUrl(url)) {
1310            switchOutDrawHistory();
1311            WebViewCore.PostUrlData arg = new WebViewCore.PostUrlData();
1312            arg.mUrl = url;
1313            arg.mPostData = postData;
1314            mWebViewCore.sendMessage(EventHub.POST_URL, arg);
1315            clearTextEntry();
1316        } else {
1317            loadUrl(url);
1318        }
1319    }
1320
1321    /**
1322     * Load the given data into the WebView. This will load the data into
1323     * WebView using the data: scheme. Content loaded through this mechanism
1324     * does not have the ability to load content from the network.
1325     * @param data A String of data in the given encoding.
1326     * @param mimeType The MIMEType of the data. i.e. text/html, image/jpeg
1327     * @param encoding The encoding of the data. i.e. utf-8, base64
1328     */
1329    public void loadData(String data, String mimeType, String encoding) {
1330        loadUrl("data:" + mimeType + ";" + encoding + "," + data);
1331    }
1332
1333    /**
1334     * Load the given data into the WebView, use the provided URL as the base
1335     * URL for the content. The base URL is the URL that represents the page
1336     * that is loaded through this interface. As such, it is used for the
1337     * history entry and to resolve any relative URLs. The failUrl is used if
1338     * browser fails to load the data provided. If it is empty or null, and the
1339     * load fails, then no history entry is created.
1340     * <p>
1341     * Note for post 1.0. Due to the change in the WebKit, the access to asset
1342     * files through "file:///android_asset/" for the sub resources is more
1343     * restricted. If you provide null or empty string as baseUrl, you won't be
1344     * able to access asset files. If the baseUrl is anything other than
1345     * http(s)/ftp(s)/about/javascript as scheme, you can access asset files for
1346     * sub resources.
1347     *
1348     * @param baseUrl Url to resolve relative paths with, if null defaults to
1349     *            "about:blank"
1350     * @param data A String of data in the given encoding.
1351     * @param mimeType The MIMEType of the data. i.e. text/html. If null,
1352     *            defaults to "text/html"
1353     * @param encoding The encoding of the data. i.e. utf-8, us-ascii
1354     * @param failUrl URL to use if the content fails to load or null.
1355     */
1356    public void loadDataWithBaseURL(String baseUrl, String data,
1357            String mimeType, String encoding, String failUrl) {
1358
1359        if (baseUrl != null && baseUrl.toLowerCase().startsWith("data:")) {
1360            loadData(data, mimeType, encoding);
1361            return;
1362        }
1363        switchOutDrawHistory();
1364        WebViewCore.BaseUrlData arg = new WebViewCore.BaseUrlData();
1365        arg.mBaseUrl = baseUrl;
1366        arg.mData = data;
1367        arg.mMimeType = mimeType;
1368        arg.mEncoding = encoding;
1369        arg.mFailUrl = failUrl;
1370        mWebViewCore.sendMessage(EventHub.LOAD_DATA, arg);
1371        clearTextEntry();
1372    }
1373
1374    /**
1375     * Stop the current load.
1376     */
1377    public void stopLoading() {
1378        // TODO: should we clear all the messages in the queue before sending
1379        // STOP_LOADING?
1380        switchOutDrawHistory();
1381        mWebViewCore.sendMessage(EventHub.STOP_LOADING);
1382    }
1383
1384    /**
1385     * Reload the current url.
1386     */
1387    public void reload() {
1388        clearTextEntry();
1389        switchOutDrawHistory();
1390        mWebViewCore.sendMessage(EventHub.RELOAD);
1391    }
1392
1393    /**
1394     * Return true if this WebView has a back history item.
1395     * @return True iff this WebView has a back history item.
1396     */
1397    public boolean canGoBack() {
1398        WebBackForwardList l = mCallbackProxy.getBackForwardList();
1399        synchronized (l) {
1400            if (l.getClearPending()) {
1401                return false;
1402            } else {
1403                return l.getCurrentIndex() > 0;
1404            }
1405        }
1406    }
1407
1408    /**
1409     * Go back in the history of this WebView.
1410     */
1411    public void goBack() {
1412        goBackOrForward(-1);
1413    }
1414
1415    /**
1416     * Return true if this WebView has a forward history item.
1417     * @return True iff this Webview has a forward history item.
1418     */
1419    public boolean canGoForward() {
1420        WebBackForwardList l = mCallbackProxy.getBackForwardList();
1421        synchronized (l) {
1422            if (l.getClearPending()) {
1423                return false;
1424            } else {
1425                return l.getCurrentIndex() < l.getSize() - 1;
1426            }
1427        }
1428    }
1429
1430    /**
1431     * Go forward in the history of this WebView.
1432     */
1433    public void goForward() {
1434        goBackOrForward(1);
1435    }
1436
1437    /**
1438     * Return true if the page can go back or forward the given
1439     * number of steps.
1440     * @param steps The negative or positive number of steps to move the
1441     *              history.
1442     */
1443    public boolean canGoBackOrForward(int steps) {
1444        WebBackForwardList l = mCallbackProxy.getBackForwardList();
1445        synchronized (l) {
1446            if (l.getClearPending()) {
1447                return false;
1448            } else {
1449                int newIndex = l.getCurrentIndex() + steps;
1450                return newIndex >= 0 && newIndex < l.getSize();
1451            }
1452        }
1453    }
1454
1455    /**
1456     * Go to the history item that is the number of steps away from
1457     * the current item. Steps is negative if backward and positive
1458     * if forward.
1459     * @param steps The number of steps to take back or forward in the back
1460     *              forward list.
1461     */
1462    public void goBackOrForward(int steps) {
1463        goBackOrForward(steps, false);
1464    }
1465
1466    private void goBackOrForward(int steps, boolean ignoreSnapshot) {
1467        // every time we go back or forward, we want to reset the
1468        // WebView certificate:
1469        // if the new site is secure, we will reload it and get a
1470        // new certificate set;
1471        // if the new site is not secure, the certificate must be
1472        // null, and that will be the case
1473        mCertificate = null;
1474        if (steps != 0) {
1475            clearTextEntry();
1476            mWebViewCore.sendMessage(EventHub.GO_BACK_FORWARD, steps,
1477                    ignoreSnapshot ? 1 : 0);
1478        }
1479    }
1480
1481    private boolean extendScroll(int y) {
1482        int finalY = mScroller.getFinalY();
1483        int newY = pinLocY(finalY + y);
1484        if (newY == finalY) return false;
1485        mScroller.setFinalY(newY);
1486        mScroller.extendDuration(computeDuration(0, y));
1487        return true;
1488    }
1489
1490    /**
1491     * Scroll the contents of the view up by half the view size
1492     * @param top true to jump to the top of the page
1493     * @return true if the page was scrolled
1494     */
1495    public boolean pageUp(boolean top) {
1496        if (mNativeClass == 0) {
1497            return false;
1498        }
1499        nativeClearCursor(); // start next trackball movement from page edge
1500        if (top) {
1501            // go to the top of the document
1502            return pinScrollTo(mScrollX, 0, true, 0);
1503        }
1504        // Page up
1505        int h = getHeight();
1506        int y;
1507        if (h > 2 * PAGE_SCROLL_OVERLAP) {
1508            y = -h + PAGE_SCROLL_OVERLAP;
1509        } else {
1510            y = -h / 2;
1511        }
1512        mUserScroll = true;
1513        return mScroller.isFinished() ? pinScrollBy(0, y, true, 0)
1514                : extendScroll(y);
1515    }
1516
1517    /**
1518     * Scroll the contents of the view down by half the page size
1519     * @param bottom true to jump to bottom of page
1520     * @return true if the page was scrolled
1521     */
1522    public boolean pageDown(boolean bottom) {
1523        if (mNativeClass == 0) {
1524            return false;
1525        }
1526        nativeClearCursor(); // start next trackball movement from page edge
1527        if (bottom) {
1528            return pinScrollTo(mScrollX, mContentHeight, true, 0);
1529        }
1530        // Page down.
1531        int h = getHeight();
1532        int y;
1533        if (h > 2 * PAGE_SCROLL_OVERLAP) {
1534            y = h - PAGE_SCROLL_OVERLAP;
1535        } else {
1536            y = h / 2;
1537        }
1538        mUserScroll = true;
1539        return mScroller.isFinished() ? pinScrollBy(0, y, true, 0)
1540                : extendScroll(y);
1541    }
1542
1543    /**
1544     * Clear the view so that onDraw() will draw nothing but white background,
1545     * and onMeasure() will return 0 if MeasureSpec is not MeasureSpec.EXACTLY
1546     */
1547    public void clearView() {
1548        mContentWidth = 0;
1549        mContentHeight = 0;
1550        mWebViewCore.sendMessage(EventHub.CLEAR_CONTENT);
1551    }
1552
1553    /**
1554     * Return a new picture that captures the current display of the webview.
1555     * This is a copy of the display, and will be unaffected if the webview
1556     * later loads a different URL.
1557     *
1558     * @return a picture containing the current contents of the view. Note this
1559     *         picture is of the entire document, and is not restricted to the
1560     *         bounds of the view.
1561     */
1562    public Picture capturePicture() {
1563        if (null == mWebViewCore) return null; // check for out of memory tab
1564        return mWebViewCore.copyContentPicture();
1565    }
1566
1567    /**
1568     *  Return true if the browser is displaying a TextView for text input.
1569     */
1570    private boolean inEditingMode() {
1571        return mWebTextView != null && mWebTextView.getParent() != null
1572                && mWebTextView.hasFocus();
1573    }
1574
1575    private void clearTextEntry() {
1576        if (inEditingMode()) {
1577            mWebTextView.remove();
1578        }
1579    }
1580
1581    /**
1582     * Return the current scale of the WebView
1583     * @return The current scale.
1584     */
1585    public float getScale() {
1586        return mActualScale;
1587    }
1588
1589    /**
1590     * Set the initial scale for the WebView. 0 means default. If
1591     * {@link WebSettings#getUseWideViewPort()} is true, it zooms out all the
1592     * way. Otherwise it starts with 100%. If initial scale is greater than 0,
1593     * WebView starts will this value as initial scale.
1594     *
1595     * @param scaleInPercent The initial scale in percent.
1596     */
1597    public void setInitialScale(int scaleInPercent) {
1598        mInitialScale = scaleInPercent;
1599    }
1600
1601    /**
1602     * Invoke the graphical zoom picker widget for this WebView. This will
1603     * result in the zoom widget appearing on the screen to control the zoom
1604     * level of this WebView.
1605     */
1606    public void invokeZoomPicker() {
1607        if (!getSettings().supportZoom()) {
1608            Log.w(LOGTAG, "This WebView doesn't support zoom.");
1609            return;
1610        }
1611        clearTextEntry();
1612        if (getSettings().getBuiltInZoomControls()) {
1613            mZoomButtonsController.setVisible(true);
1614        } else {
1615            mPrivateHandler.removeCallbacks(mZoomControlRunnable);
1616            mPrivateHandler.postDelayed(mZoomControlRunnable,
1617                    ZOOM_CONTROLS_TIMEOUT);
1618        }
1619    }
1620
1621    /**
1622     * Return a HitTestResult based on the current cursor node. If a HTML::a tag
1623     * is found and the anchor has a non-javascript url, the HitTestResult type
1624     * is set to SRC_ANCHOR_TYPE and the url is set in the "extra" field. If the
1625     * anchor does not have a url or if it is a javascript url, the type will
1626     * be UNKNOWN_TYPE and the url has to be retrieved through
1627     * {@link #requestFocusNodeHref} asynchronously. If a HTML::img tag is
1628     * found, the HitTestResult type is set to IMAGE_TYPE and the url is set in
1629     * the "extra" field. A type of
1630     * SRC_IMAGE_ANCHOR_TYPE indicates an anchor with a url that has an image as
1631     * a child node. If a phone number is found, the HitTestResult type is set
1632     * to PHONE_TYPE and the phone number is set in the "extra" field of
1633     * HitTestResult. If a map address is found, the HitTestResult type is set
1634     * to GEO_TYPE and the address is set in the "extra" field of HitTestResult.
1635     * If an email address is found, the HitTestResult type is set to EMAIL_TYPE
1636     * and the email is set in the "extra" field of HitTestResult. Otherwise,
1637     * HitTestResult type is set to UNKNOWN_TYPE.
1638     */
1639    public HitTestResult getHitTestResult() {
1640        if (mNativeClass == 0) {
1641            return null;
1642        }
1643
1644        HitTestResult result = new HitTestResult();
1645        if (nativeHasCursorNode()) {
1646            if (nativeCursorIsTextInput()) {
1647                result.setType(HitTestResult.EDIT_TEXT_TYPE);
1648            } else {
1649                String text = nativeCursorText();
1650                if (text != null) {
1651                    if (text.startsWith(SCHEME_TEL)) {
1652                        result.setType(HitTestResult.PHONE_TYPE);
1653                        result.setExtra(text.substring(SCHEME_TEL.length()));
1654                    } else if (text.startsWith(SCHEME_MAILTO)) {
1655                        result.setType(HitTestResult.EMAIL_TYPE);
1656                        result.setExtra(text.substring(SCHEME_MAILTO.length()));
1657                    } else if (text.startsWith(SCHEME_GEO)) {
1658                        result.setType(HitTestResult.GEO_TYPE);
1659                        result.setExtra(URLDecoder.decode(text
1660                                .substring(SCHEME_GEO.length())));
1661                    } else if (nativeCursorIsAnchor()) {
1662                        result.setType(HitTestResult.SRC_ANCHOR_TYPE);
1663                        result.setExtra(text);
1664                    }
1665                }
1666            }
1667        }
1668        int type = result.getType();
1669        if (type == HitTestResult.UNKNOWN_TYPE
1670                || type == HitTestResult.SRC_ANCHOR_TYPE) {
1671            // Now check to see if it is an image.
1672            int contentX = viewToContentX((int) mLastTouchX + mScrollX);
1673            int contentY = viewToContentY((int) mLastTouchY + mScrollY);
1674            String text = nativeImageURI(contentX, contentY);
1675            if (text != null) {
1676                result.setType(type == HitTestResult.UNKNOWN_TYPE ?
1677                        HitTestResult.IMAGE_TYPE :
1678                        HitTestResult.SRC_IMAGE_ANCHOR_TYPE);
1679                result.setExtra(text);
1680            }
1681        }
1682        return result;
1683    }
1684
1685    /**
1686     * Request the href of an anchor element due to getFocusNodePath returning
1687     * "href." If hrefMsg is null, this method returns immediately and does not
1688     * dispatch hrefMsg to its target.
1689     *
1690     * @param hrefMsg This message will be dispatched with the result of the
1691     *            request as the data member with "url" as key. The result can
1692     *            be null.
1693     */
1694    // FIXME: API change required to change the name of this function.  We now
1695    // look at the cursor node, and not the focus node.  Also, what is
1696    // getFocusNodePath?
1697    public void requestFocusNodeHref(Message hrefMsg) {
1698        if (hrefMsg == null || mNativeClass == 0) {
1699            return;
1700        }
1701        if (nativeCursorIsAnchor()) {
1702            mWebViewCore.sendMessage(EventHub.REQUEST_CURSOR_HREF,
1703                    nativeCursorFramePointer(), nativeCursorNodePointer(),
1704                    hrefMsg);
1705        }
1706    }
1707
1708    /**
1709     * Request the url of the image last touched by the user. msg will be sent
1710     * to its target with a String representing the url as its object.
1711     *
1712     * @param msg This message will be dispatched with the result of the request
1713     *            as the data member with "url" as key. The result can be null.
1714     */
1715    public void requestImageRef(Message msg) {
1716        int contentX = viewToContentX((int) mLastTouchX + mScrollX);
1717        int contentY = viewToContentY((int) mLastTouchY + mScrollY);
1718        String ref = nativeImageURI(contentX, contentY);
1719        Bundle data = msg.getData();
1720        data.putString("url", ref);
1721        msg.setData(data);
1722        msg.sendToTarget();
1723    }
1724
1725    private static int pinLoc(int x, int viewMax, int docMax) {
1726//        Log.d(LOGTAG, "-- pinLoc " + x + " " + viewMax + " " + docMax);
1727        if (docMax < viewMax) {   // the doc has room on the sides for "blank"
1728            // pin the short document to the top/left of the screen
1729            x = 0;
1730//            Log.d(LOGTAG, "--- center " + x);
1731        } else if (x < 0) {
1732            x = 0;
1733//            Log.d(LOGTAG, "--- zero");
1734        } else if (x + viewMax > docMax) {
1735            x = docMax - viewMax;
1736//            Log.d(LOGTAG, "--- pin " + x);
1737        }
1738        return x;
1739    }
1740
1741    // Expects x in view coordinates
1742    private int pinLocX(int x) {
1743        return pinLoc(x, getViewWidth(), computeHorizontalScrollRange());
1744    }
1745
1746    // Expects y in view coordinates
1747    private int pinLocY(int y) {
1748        int titleH = getTitleHeight();
1749        // if the titlebar is still visible, just pin against 0
1750        if (y <= titleH) {
1751            return Math.max(y, 0);
1752        }
1753        // convert to 0-based coordinate (subtract the title height)
1754        // pin(), and then add the title height back in
1755        return pinLoc(y - titleH, getViewHeight(),
1756                      computeVerticalScrollRange()) + titleH;
1757    }
1758
1759    /**
1760     * A title bar which is embedded in this WebView, and scrolls along with it
1761     * vertically, but not horizontally.
1762     */
1763    private View mTitleBar;
1764
1765    /**
1766     * Since we draw the title bar ourselves, we removed the shadow from the
1767     * browser's activity.  We do want a shadow at the bottom of the title bar,
1768     * or at the top of the screen if the title bar is not visible.  This
1769     * drawable serves that purpose.
1770     */
1771    private Drawable mTitleShadow;
1772
1773    /**
1774     * Add or remove a title bar to be embedded into the WebView, and scroll
1775     * along with it vertically, while remaining in view horizontally. Pass
1776     * null to remove the title bar from the WebView, and return to drawing
1777     * the WebView normally without translating to account for the title bar.
1778     * @hide
1779     */
1780    public void setEmbeddedTitleBar(View v) {
1781        if (mTitleBar == v) return;
1782        if (mTitleBar != null) {
1783            removeView(mTitleBar);
1784        }
1785        if (null != v) {
1786            addView(v, new AbsoluteLayout.LayoutParams(
1787                    ViewGroup.LayoutParams.FILL_PARENT,
1788                    ViewGroup.LayoutParams.WRAP_CONTENT, 0, 0));
1789            if (mTitleShadow == null) {
1790                mTitleShadow = (Drawable) mContext.getResources().getDrawable(
1791                        com.android.internal.R.drawable.title_bar_shadow);
1792            }
1793        }
1794        mTitleBar = v;
1795    }
1796
1797    /**
1798     * Given a distance in view space, convert it to content space. Note: this
1799     * does not reflect translation, just scaling, so this should not be called
1800     * with coordinates, but should be called for dimensions like width or
1801     * height.
1802     */
1803    private int viewToContentDimension(int d) {
1804        return Math.round(d * mInvActualScale);
1805    }
1806
1807    /**
1808     * Given an x coordinate in view space, convert it to content space.  Also
1809     * may be used for absolute heights (such as for the WebTextView's
1810     * textSize, which is unaffected by the height of the title bar).
1811     */
1812    /*package*/ int viewToContentX(int x) {
1813        return viewToContentDimension(x);
1814    }
1815
1816    /**
1817     * Given a y coordinate in view space, convert it to content space.
1818     * Takes into account the height of the title bar if there is one
1819     * embedded into the WebView.
1820     */
1821    /*package*/ int viewToContentY(int y) {
1822        return viewToContentDimension(y - getTitleHeight());
1823    }
1824
1825    /**
1826     * Given a distance in content space, convert it to view space. Note: this
1827     * does not reflect translation, just scaling, so this should not be called
1828     * with coordinates, but should be called for dimensions like width or
1829     * height.
1830     */
1831    /*package*/ int contentToViewDimension(int d) {
1832        return Math.round(d * mActualScale);
1833    }
1834
1835    /**
1836     * Given an x coordinate in content space, convert it to view
1837     * space.
1838     */
1839    /*package*/ int contentToViewX(int x) {
1840        return contentToViewDimension(x);
1841    }
1842
1843    /**
1844     * Given a y coordinate in content space, convert it to view
1845     * space.  Takes into account the height of the title bar.
1846     */
1847    /*package*/ int contentToViewY(int y) {
1848        return contentToViewDimension(y) + getTitleHeight();
1849    }
1850
1851    private Rect contentToViewRect(Rect x) {
1852        return new Rect(contentToViewX(x.left), contentToViewY(x.top),
1853                        contentToViewX(x.right), contentToViewY(x.bottom));
1854    }
1855
1856    /*  To invalidate a rectangle in content coordinates, we need to transform
1857        the rect into view coordinates, so we can then call invalidate(...).
1858
1859        Normally, we would just call contentToView[XY](...), which eventually
1860        calls Math.round(coordinate * mActualScale). However, for invalidates,
1861        we need to account for the slop that occurs with antialiasing. To
1862        address that, we are a little more liberal in the size of the rect that
1863        we invalidate.
1864
1865        This liberal calculation calls floor() for the top/left, and ceil() for
1866        the bottom/right coordinates. This catches the possible extra pixels of
1867        antialiasing that we might have missed with just round().
1868     */
1869
1870    // Called by JNI to invalidate the View, given rectangle coordinates in
1871    // content space
1872    private void viewInvalidate(int l, int t, int r, int b) {
1873        final float scale = mActualScale;
1874        final int dy = getTitleHeight();
1875        invalidate((int)Math.floor(l * scale),
1876                   (int)Math.floor(t * scale) + dy,
1877                   (int)Math.ceil(r * scale),
1878                   (int)Math.ceil(b * scale) + dy);
1879    }
1880
1881    // Called by JNI to invalidate the View after a delay, given rectangle
1882    // coordinates in content space
1883    private void viewInvalidateDelayed(long delay, int l, int t, int r, int b) {
1884        final float scale = mActualScale;
1885        final int dy = getTitleHeight();
1886        postInvalidateDelayed(delay,
1887                              (int)Math.floor(l * scale),
1888                              (int)Math.floor(t * scale) + dy,
1889                              (int)Math.ceil(r * scale),
1890                              (int)Math.ceil(b * scale) + dy);
1891    }
1892
1893    private void invalidateContentRect(Rect r) {
1894        viewInvalidate(r.left, r.top, r.right, r.bottom);
1895    }
1896
1897    // stop the scroll animation, and don't let a subsequent fling add
1898    // to the existing velocity
1899    private void abortAnimation() {
1900        mScroller.abortAnimation();
1901        mLastVelocity = 0;
1902    }
1903
1904    /* call from webcoreview.draw(), so we're still executing in the UI thread
1905    */
1906    private void recordNewContentSize(int w, int h, boolean updateLayout) {
1907
1908        // premature data from webkit, ignore
1909        if ((w | h) == 0) {
1910            return;
1911        }
1912
1913        // don't abort a scroll animation if we didn't change anything
1914        if (mContentWidth != w || mContentHeight != h) {
1915            // record new dimensions
1916            mContentWidth = w;
1917            mContentHeight = h;
1918            // If history Picture is drawn, don't update scroll. They will be
1919            // updated when we get out of that mode.
1920            if (!mDrawHistory) {
1921                // repin our scroll, taking into account the new content size
1922                int oldX = mScrollX;
1923                int oldY = mScrollY;
1924                mScrollX = pinLocX(mScrollX);
1925                mScrollY = pinLocY(mScrollY);
1926                if (oldX != mScrollX || oldY != mScrollY) {
1927                    sendOurVisibleRect();
1928                }
1929                if (!mScroller.isFinished()) {
1930                    // We are in the middle of a scroll.  Repin the final scroll
1931                    // position.
1932                    mScroller.setFinalX(pinLocX(mScroller.getFinalX()));
1933                    mScroller.setFinalY(pinLocY(mScroller.getFinalY()));
1934                }
1935            }
1936        }
1937        contentSizeChanged(updateLayout);
1938    }
1939
1940    private void setNewZoomScale(float scale, boolean force) {
1941        if (scale < mMinZoomScale) {
1942            scale = mMinZoomScale;
1943        } else if (scale > mMaxZoomScale) {
1944            scale = mMaxZoomScale;
1945        }
1946        if (scale != mActualScale || force) {
1947            if (mDrawHistory) {
1948                // If history Picture is drawn, don't update scroll. They will
1949                // be updated when we get out of that mode.
1950                if (scale != mActualScale && !mPreviewZoomOnly) {
1951                    mCallbackProxy.onScaleChanged(mActualScale, scale);
1952                }
1953                mActualScale = scale;
1954                mInvActualScale = 1 / scale;
1955                if (!mPreviewZoomOnly) {
1956                    sendViewSizeZoom();
1957                }
1958            } else {
1959                // update our scroll so we don't appear to jump
1960                // i.e. keep the center of the doc in the center of the view
1961
1962                int oldX = mScrollX;
1963                int oldY = mScrollY;
1964                float ratio = scale * mInvActualScale;   // old inverse
1965                float sx = ratio * oldX + (ratio - 1) * mZoomCenterX;
1966                float sy = ratio * oldY + (ratio - 1)
1967                        * (mZoomCenterY - getTitleHeight());
1968
1969                // now update our new scale and inverse
1970                if (scale != mActualScale && !mPreviewZoomOnly) {
1971                    mCallbackProxy.onScaleChanged(mActualScale, scale);
1972                }
1973                mActualScale = scale;
1974                mInvActualScale = 1 / scale;
1975
1976                // Scale all the child views
1977                mViewManager.scaleAll();
1978
1979                // as we don't have animation for scaling, don't do animation
1980                // for scrolling, as it causes weird intermediate state
1981                //        pinScrollTo(Math.round(sx), Math.round(sy));
1982                mScrollX = pinLocX(Math.round(sx));
1983                mScrollY = pinLocY(Math.round(sy));
1984
1985                if (!mPreviewZoomOnly) {
1986                    sendViewSizeZoom();
1987                    sendOurVisibleRect();
1988                }
1989            }
1990        }
1991    }
1992
1993    // Used to avoid sending many visible rect messages.
1994    private Rect mLastVisibleRectSent;
1995    private Rect mLastGlobalRect;
1996
1997    private Rect sendOurVisibleRect() {
1998        Rect rect = new Rect();
1999        calcOurContentVisibleRect(rect);
2000        // Rect.equals() checks for null input.
2001        if (!rect.equals(mLastVisibleRectSent)) {
2002            Point pos = new Point(rect.left, rect.top);
2003            mWebViewCore.sendMessage(EventHub.SET_SCROLL_OFFSET,
2004                    nativeMoveGeneration(), 0, pos);
2005            mLastVisibleRectSent = rect;
2006        }
2007        Rect globalRect = new Rect();
2008        if (getGlobalVisibleRect(globalRect)
2009                && !globalRect.equals(mLastGlobalRect)) {
2010            if (DebugFlags.WEB_VIEW) {
2011                Log.v(LOGTAG, "sendOurVisibleRect=(" + globalRect.left + ","
2012                        + globalRect.top + ",r=" + globalRect.right + ",b="
2013                        + globalRect.bottom);
2014            }
2015            // TODO: the global offset is only used by windowRect()
2016            // in ChromeClientAndroid ; other clients such as touch
2017            // and mouse events could return view + screen relative points.
2018            mWebViewCore.sendMessage(EventHub.SET_GLOBAL_BOUNDS, globalRect);
2019            mLastGlobalRect = globalRect;
2020        }
2021        return rect;
2022    }
2023
2024    // Sets r to be the visible rectangle of our webview in view coordinates
2025    private void calcOurVisibleRect(Rect r) {
2026        Point p = new Point();
2027        getGlobalVisibleRect(r, p);
2028        r.offset(-p.x, -p.y);
2029        if (mFindIsUp) {
2030            r.bottom -= mFindHeight;
2031        }
2032    }
2033
2034    // Sets r to be our visible rectangle in content coordinates
2035    private void calcOurContentVisibleRect(Rect r) {
2036        calcOurVisibleRect(r);
2037        r.left = viewToContentX(r.left);
2038        // viewToContentY will remove the total height of the title bar.  Add
2039        // the visible height back in to account for the fact that if the title
2040        // bar is partially visible, the part of the visible rect which is
2041        // displaying our content is displaced by that amount.
2042        r.top = viewToContentY(r.top + getVisibleTitleHeight());
2043        r.right = viewToContentX(r.right);
2044        r.bottom = viewToContentY(r.bottom);
2045    }
2046
2047    static class ViewSizeData {
2048        int mWidth;
2049        int mHeight;
2050        int mTextWrapWidth;
2051        float mScale;
2052        boolean mIgnoreHeight;
2053    }
2054
2055    /**
2056     * Compute unzoomed width and height, and if they differ from the last
2057     * values we sent, send them to webkit (to be used has new viewport)
2058     *
2059     * @return true if new values were sent
2060     */
2061    private boolean sendViewSizeZoom() {
2062        int viewWidth = getViewWidth();
2063        int newWidth = Math.round(viewWidth * mInvActualScale);
2064        int newHeight = Math.round(getViewHeight() * mInvActualScale);
2065        /*
2066         * Because the native side may have already done a layout before the
2067         * View system was able to measure us, we have to send a height of 0 to
2068         * remove excess whitespace when we grow our width. This will trigger a
2069         * layout and a change in content size. This content size change will
2070         * mean that contentSizeChanged will either call this method directly or
2071         * indirectly from onSizeChanged.
2072         */
2073        if (newWidth > mLastWidthSent && mWrapContent) {
2074            newHeight = 0;
2075        }
2076        // Avoid sending another message if the dimensions have not changed.
2077        if (newWidth != mLastWidthSent || newHeight != mLastHeightSent) {
2078            ViewSizeData data = new ViewSizeData();
2079            data.mWidth = newWidth;
2080            data.mHeight = newHeight;
2081            // while in zoom overview mode, the text are wrapped to the screen
2082            // width matching mLastScale. So that we don't trigger re-flow while
2083            // toggling between overview mode and normal mode.
2084            data.mTextWrapWidth = mInZoomOverview ? Math.round(viewWidth
2085                    / mLastScale) : newWidth;
2086            data.mScale = mActualScale;
2087            data.mIgnoreHeight = mZoomScale != 0 && !mHeightCanMeasure;
2088            mWebViewCore.sendMessage(EventHub.VIEW_SIZE_CHANGED, data);
2089            mLastWidthSent = newWidth;
2090            mLastHeightSent = newHeight;
2091            return true;
2092        }
2093        return false;
2094    }
2095
2096    @Override
2097    protected int computeHorizontalScrollRange() {
2098        if (mDrawHistory) {
2099            return mHistoryWidth;
2100        } else {
2101            // to avoid rounding error caused unnecessary scrollbar, use floor
2102            return (int) Math.floor(mContentWidth * mActualScale);
2103        }
2104    }
2105
2106    @Override
2107    protected int computeVerticalScrollRange() {
2108        if (mDrawHistory) {
2109            return mHistoryHeight;
2110        } else {
2111            // to avoid rounding error caused unnecessary scrollbar, use floor
2112            return (int) Math.floor(mContentHeight * mActualScale);
2113        }
2114    }
2115
2116    @Override
2117    protected int computeVerticalScrollOffset() {
2118        return Math.max(mScrollY - getTitleHeight(), 0);
2119    }
2120
2121    @Override
2122    protected int computeVerticalScrollExtent() {
2123        return getViewHeight();
2124    }
2125
2126    /** @hide */
2127    @Override
2128    protected void onDrawVerticalScrollBar(Canvas canvas,
2129                                           Drawable scrollBar,
2130                                           int l, int t, int r, int b) {
2131        scrollBar.setBounds(l, t + getVisibleTitleHeight(), r, b);
2132        scrollBar.draw(canvas);
2133    }
2134
2135    /**
2136     * Get the url for the current page. This is not always the same as the url
2137     * passed to WebViewClient.onPageStarted because although the load for
2138     * that url has begun, the current page may not have changed.
2139     * @return The url for the current page.
2140     */
2141    public String getUrl() {
2142        WebHistoryItem h = mCallbackProxy.getBackForwardList().getCurrentItem();
2143        return h != null ? h.getUrl() : null;
2144    }
2145
2146    /**
2147     * Get the original url for the current page. This is not always the same
2148     * as the url passed to WebViewClient.onPageStarted because although the
2149     * load for that url has begun, the current page may not have changed.
2150     * Also, there may have been redirects resulting in a different url to that
2151     * originally requested.
2152     * @return The url that was originally requested for the current page.
2153     */
2154    public String getOriginalUrl() {
2155        WebHistoryItem h = mCallbackProxy.getBackForwardList().getCurrentItem();
2156        return h != null ? h.getOriginalUrl() : null;
2157    }
2158
2159    /**
2160     * Get the title for the current page. This is the title of the current page
2161     * until WebViewClient.onReceivedTitle is called.
2162     * @return The title for the current page.
2163     */
2164    public String getTitle() {
2165        WebHistoryItem h = mCallbackProxy.getBackForwardList().getCurrentItem();
2166        return h != null ? h.getTitle() : null;
2167    }
2168
2169    /**
2170     * Get the favicon for the current page. This is the favicon of the current
2171     * page until WebViewClient.onReceivedIcon is called.
2172     * @return The favicon for the current page.
2173     */
2174    public Bitmap getFavicon() {
2175        WebHistoryItem h = mCallbackProxy.getBackForwardList().getCurrentItem();
2176        return h != null ? h.getFavicon() : null;
2177    }
2178
2179    /**
2180     * Get the touch icon url for the apple-touch-icon <link> element.
2181     * @hide
2182     */
2183    public String getTouchIconUrl() {
2184        WebHistoryItem h = mCallbackProxy.getBackForwardList().getCurrentItem();
2185        return h != null ? h.getTouchIconUrl() : null;
2186    }
2187
2188    /**
2189     * Get the progress for the current page.
2190     * @return The progress for the current page between 0 and 100.
2191     */
2192    public int getProgress() {
2193        return mCallbackProxy.getProgress();
2194    }
2195
2196    /**
2197     * @return the height of the HTML content.
2198     */
2199    public int getContentHeight() {
2200        return mContentHeight;
2201    }
2202
2203    /**
2204     * @return the width of the HTML content.
2205     * @hide
2206     */
2207    public int getContentWidth() {
2208        return mContentWidth;
2209    }
2210
2211    /**
2212     * Pause all layout, parsing, and javascript timers for all webviews. This
2213     * is a global requests, not restricted to just this webview. This can be
2214     * useful if the application has been paused.
2215     */
2216    public void pauseTimers() {
2217        mWebViewCore.sendMessage(EventHub.PAUSE_TIMERS);
2218    }
2219
2220    /**
2221     * Resume all layout, parsing, and javascript timers for all webviews.
2222     * This will resume dispatching all timers.
2223     */
2224    public void resumeTimers() {
2225        mWebViewCore.sendMessage(EventHub.RESUME_TIMERS);
2226    }
2227
2228    /**
2229     * Call this to pause any extra processing associated with this view and
2230     * its associated DOM/plugins/javascript/etc. For example, if the view is
2231     * taken offscreen, this could be called to reduce unnecessary CPU and/or
2232     * network traffic. When the view is again "active", call onResume().
2233     *
2234     * Note that this differs from pauseTimers(), which affects all views/DOMs
2235     * @hide
2236     */
2237    public void onPause() {
2238        if (!mIsPaused) {
2239            mIsPaused = true;
2240            mWebViewCore.sendMessage(EventHub.ON_PAUSE);
2241        }
2242    }
2243
2244    /**
2245     * Call this to balanace a previous call to onPause()
2246     * @hide
2247     */
2248    public void onResume() {
2249        if (mIsPaused) {
2250            mIsPaused = false;
2251            mWebViewCore.sendMessage(EventHub.ON_RESUME);
2252        }
2253    }
2254
2255    /**
2256     * Returns true if the view is paused, meaning onPause() was called. Calling
2257     * onResume() sets the paused state back to false.
2258     * @hide
2259     */
2260    public boolean isPaused() {
2261        return mIsPaused;
2262    }
2263
2264    /**
2265     * Call this to inform the view that memory is low so that it can
2266     * free any available memory.
2267     * @hide
2268     */
2269    public void freeMemory() {
2270        mWebViewCore.sendMessage(EventHub.FREE_MEMORY);
2271    }
2272
2273    /**
2274     * Clear the resource cache. Note that the cache is per-application, so
2275     * this will clear the cache for all WebViews used.
2276     *
2277     * @param includeDiskFiles If false, only the RAM cache is cleared.
2278     */
2279    public void clearCache(boolean includeDiskFiles) {
2280        // Note: this really needs to be a static method as it clears cache for all
2281        // WebView. But we need mWebViewCore to send message to WebCore thread, so
2282        // we can't make this static.
2283        mWebViewCore.sendMessage(EventHub.CLEAR_CACHE,
2284                includeDiskFiles ? 1 : 0, 0);
2285    }
2286
2287    /**
2288     * Make sure that clearing the form data removes the adapter from the
2289     * currently focused textfield if there is one.
2290     */
2291    public void clearFormData() {
2292        if (inEditingMode()) {
2293            AutoCompleteAdapter adapter = null;
2294            mWebTextView.setAdapterCustom(adapter);
2295        }
2296    }
2297
2298    /**
2299     * Tell the WebView to clear its internal back/forward list.
2300     */
2301    public void clearHistory() {
2302        mCallbackProxy.getBackForwardList().setClearPending();
2303        mWebViewCore.sendMessage(EventHub.CLEAR_HISTORY);
2304    }
2305
2306    /**
2307     * Clear the SSL preferences table stored in response to proceeding with SSL
2308     * certificate errors.
2309     */
2310    public void clearSslPreferences() {
2311        mWebViewCore.sendMessage(EventHub.CLEAR_SSL_PREF_TABLE);
2312    }
2313
2314    /**
2315     * Return the WebBackForwardList for this WebView. This contains the
2316     * back/forward list for use in querying each item in the history stack.
2317     * This is a copy of the private WebBackForwardList so it contains only a
2318     * snapshot of the current state. Multiple calls to this method may return
2319     * different objects. The object returned from this method will not be
2320     * updated to reflect any new state.
2321     */
2322    public WebBackForwardList copyBackForwardList() {
2323        return mCallbackProxy.getBackForwardList().clone();
2324    }
2325
2326    /*
2327     * Highlight and scroll to the next occurance of String in findAll.
2328     * Wraps the page infinitely, and scrolls.  Must be called after
2329     * calling findAll.
2330     *
2331     * @param forward Direction to search.
2332     */
2333    public void findNext(boolean forward) {
2334        nativeFindNext(forward);
2335    }
2336
2337    /*
2338     * Find all instances of find on the page and highlight them.
2339     * @param find  String to find.
2340     * @return int  The number of occurances of the String "find"
2341     *              that were found.
2342     */
2343    public int findAll(String find) {
2344        if (mFindIsUp == false) {
2345            recordNewContentSize(mContentWidth, mContentHeight + mFindHeight,
2346                    false);
2347            mFindIsUp = true;
2348        }
2349        int result = nativeFindAll(find.toLowerCase(), find.toUpperCase());
2350        invalidate();
2351        return result;
2352    }
2353
2354    // Used to know whether the find dialog is open.  Affects whether
2355    // or not we draw the highlights for matches.
2356    private boolean mFindIsUp;
2357    private int mFindHeight;
2358
2359    /**
2360     * Return the first substring consisting of the address of a physical
2361     * location. Currently, only addresses in the United States are detected,
2362     * and consist of:
2363     * - a house number
2364     * - a street name
2365     * - a street type (Road, Circle, etc), either spelled out or abbreviated
2366     * - a city name
2367     * - a state or territory, either spelled out or two-letter abbr.
2368     * - an optional 5 digit or 9 digit zip code.
2369     *
2370     * All names must be correctly capitalized, and the zip code, if present,
2371     * must be valid for the state. The street type must be a standard USPS
2372     * spelling or abbreviation. The state or territory must also be spelled
2373     * or abbreviated using USPS standards. The house number may not exceed
2374     * five digits.
2375     * @param addr The string to search for addresses.
2376     *
2377     * @return the address, or if no address is found, return null.
2378     */
2379    public static String findAddress(String addr) {
2380        return findAddress(addr, false);
2381    }
2382
2383    /**
2384     * @hide
2385     * Return the first substring consisting of the address of a physical
2386     * location. Currently, only addresses in the United States are detected,
2387     * and consist of:
2388     * - a house number
2389     * - a street name
2390     * - a street type (Road, Circle, etc), either spelled out or abbreviated
2391     * - a city name
2392     * - a state or territory, either spelled out or two-letter abbr.
2393     * - an optional 5 digit or 9 digit zip code.
2394     *
2395     * Names are optionally capitalized, and the zip code, if present,
2396     * must be valid for the state. The street type must be a standard USPS
2397     * spelling or abbreviation. The state or territory must also be spelled
2398     * or abbreviated using USPS standards. The house number may not exceed
2399     * five digits.
2400     * @param addr The string to search for addresses.
2401     * @param caseInsensitive addr Set to true to make search ignore case.
2402     *
2403     * @return the address, or if no address is found, return null.
2404     */
2405    public static String findAddress(String addr, boolean caseInsensitive) {
2406        return WebViewCore.nativeFindAddress(addr, caseInsensitive);
2407    }
2408
2409    /*
2410     * Clear the highlighting surrounding text matches created by findAll.
2411     */
2412    public void clearMatches() {
2413        if (mFindIsUp) {
2414            recordNewContentSize(mContentWidth, mContentHeight - mFindHeight,
2415                    false);
2416            mFindIsUp = false;
2417        }
2418        nativeSetFindIsDown();
2419        // Now that the dialog has been removed, ensure that we scroll to a
2420        // location that is not beyond the end of the page.
2421        pinScrollTo(mScrollX, mScrollY, false, 0);
2422        invalidate();
2423    }
2424
2425    /**
2426     * @hide
2427     */
2428    public void setFindDialogHeight(int height) {
2429        if (DebugFlags.WEB_VIEW) {
2430            Log.v(LOGTAG, "setFindDialogHeight height=" + height);
2431        }
2432        mFindHeight = height;
2433    }
2434
2435    /**
2436     * Query the document to see if it contains any image references. The
2437     * message object will be dispatched with arg1 being set to 1 if images
2438     * were found and 0 if the document does not reference any images.
2439     * @param response The message that will be dispatched with the result.
2440     */
2441    public void documentHasImages(Message response) {
2442        if (response == null) {
2443            return;
2444        }
2445        mWebViewCore.sendMessage(EventHub.DOC_HAS_IMAGES, response);
2446    }
2447
2448    @Override
2449    public void computeScroll() {
2450        if (mScroller.computeScrollOffset()) {
2451            int oldX = mScrollX;
2452            int oldY = mScrollY;
2453            mScrollX = mScroller.getCurrX();
2454            mScrollY = mScroller.getCurrY();
2455            postInvalidate();  // So we draw again
2456            if (oldX != mScrollX || oldY != mScrollY) {
2457                // as onScrollChanged() is not called, sendOurVisibleRect()
2458                // needs to be call explicitly
2459                sendOurVisibleRect();
2460            }
2461        } else {
2462            super.computeScroll();
2463        }
2464    }
2465
2466    private static int computeDuration(int dx, int dy) {
2467        int distance = Math.max(Math.abs(dx), Math.abs(dy));
2468        int duration = distance * 1000 / STD_SPEED;
2469        return Math.min(duration, MAX_DURATION);
2470    }
2471
2472    // helper to pin the scrollBy parameters (already in view coordinates)
2473    // returns true if the scroll was changed
2474    private boolean pinScrollBy(int dx, int dy, boolean animate, int animationDuration) {
2475        return pinScrollTo(mScrollX + dx, mScrollY + dy, animate, animationDuration);
2476    }
2477    // helper to pin the scrollTo parameters (already in view coordinates)
2478    // returns true if the scroll was changed
2479    private boolean pinScrollTo(int x, int y, boolean animate, int animationDuration) {
2480        x = pinLocX(x);
2481        y = pinLocY(y);
2482        int dx = x - mScrollX;
2483        int dy = y - mScrollY;
2484
2485        if ((dx | dy) == 0) {
2486            return false;
2487        }
2488        if (animate) {
2489            //        Log.d(LOGTAG, "startScroll: " + dx + " " + dy);
2490            mScroller.startScroll(mScrollX, mScrollY, dx, dy,
2491                    animationDuration > 0 ? animationDuration : computeDuration(dx, dy));
2492            awakenScrollBars(mScroller.getDuration());
2493            invalidate();
2494        } else {
2495            abortAnimation(); // just in case
2496            scrollTo(x, y);
2497        }
2498        return true;
2499    }
2500
2501    // Scale from content to view coordinates, and pin.
2502    // Also called by jni webview.cpp
2503    private boolean setContentScrollBy(int cx, int cy, boolean animate) {
2504        if (mDrawHistory) {
2505            // disallow WebView to change the scroll position as History Picture
2506            // is used in the view system.
2507            // TODO: as we switchOutDrawHistory when trackball or navigation
2508            // keys are hit, this should be safe. Right?
2509            return false;
2510        }
2511        cx = contentToViewDimension(cx);
2512        cy = contentToViewDimension(cy);
2513        if (mHeightCanMeasure) {
2514            // move our visible rect according to scroll request
2515            if (cy != 0) {
2516                Rect tempRect = new Rect();
2517                calcOurVisibleRect(tempRect);
2518                tempRect.offset(cx, cy);
2519                requestRectangleOnScreen(tempRect);
2520            }
2521            // FIXME: We scroll horizontally no matter what because currently
2522            // ScrollView and ListView will not scroll horizontally.
2523            // FIXME: Why do we only scroll horizontally if there is no
2524            // vertical scroll?
2525//                Log.d(LOGTAG, "setContentScrollBy cy=" + cy);
2526            return cy == 0 && cx != 0 && pinScrollBy(cx, 0, animate, 0);
2527        } else {
2528            return pinScrollBy(cx, cy, animate, 0);
2529        }
2530    }
2531
2532    // scale from content to view coordinates, and pin
2533    // return true if pin caused the final x/y different than the request cx/cy,
2534    // and a future scroll may reach the request cx/cy after our size has
2535    // changed
2536    // return false if the view scroll to the exact position as it is requested,
2537    // where negative numbers are taken to mean 0
2538    private boolean setContentScrollTo(int cx, int cy) {
2539        if (mDrawHistory) {
2540            // disallow WebView to change the scroll position as History Picture
2541            // is used in the view system.
2542            // One known case where this is called is that WebCore tries to
2543            // restore the scroll position. As history Picture already uses the
2544            // saved scroll position, it is ok to skip this.
2545            return false;
2546        }
2547        int vx;
2548        int vy;
2549        if ((cx | cy) == 0) {
2550            // If the page is being scrolled to (0,0), do not add in the title
2551            // bar's height, and simply scroll to (0,0). (The only other work
2552            // in contentToView_ is to multiply, so this would not change 0.)
2553            vx = 0;
2554            vy = 0;
2555        } else {
2556            vx = contentToViewX(cx);
2557            vy = contentToViewY(cy);
2558        }
2559//        Log.d(LOGTAG, "content scrollTo [" + cx + " " + cy + "] view=[" +
2560//                      vx + " " + vy + "]");
2561        // Some mobile sites attempt to scroll the title bar off the page by
2562        // scrolling to (0,1).  If we are at the top left corner of the
2563        // page, assume this is an attempt to scroll off the title bar, and
2564        // animate the title bar off screen slowly enough that the user can see
2565        // it.
2566        if (cx == 0 && cy == 1 && mScrollX == 0 && mScrollY == 0) {
2567            pinScrollTo(vx, vy, true, SLIDE_TITLE_DURATION);
2568            // Since we are animating, we have not yet reached the desired
2569            // scroll position.  Do not return true to request another attempt
2570            return false;
2571        }
2572        pinScrollTo(vx, vy, false, 0);
2573        // If the request was to scroll to a negative coordinate, treat it as if
2574        // it was a request to scroll to 0
2575        if ((mScrollX != vx && cx >= 0) || (mScrollY != vy && cy >= 0)) {
2576            return true;
2577        } else {
2578            return false;
2579        }
2580    }
2581
2582    // scale from content to view coordinates, and pin
2583    private void spawnContentScrollTo(int cx, int cy) {
2584        if (mDrawHistory) {
2585            // disallow WebView to change the scroll position as History Picture
2586            // is used in the view system.
2587            return;
2588        }
2589        int vx = contentToViewX(cx);
2590        int vy = contentToViewY(cy);
2591        pinScrollTo(vx, vy, true, 0);
2592    }
2593
2594    /**
2595     * These are from webkit, and are in content coordinate system (unzoomed)
2596     */
2597    private void contentSizeChanged(boolean updateLayout) {
2598        // suppress 0,0 since we usually see real dimensions soon after
2599        // this avoids drawing the prev content in a funny place. If we find a
2600        // way to consolidate these notifications, this check may become
2601        // obsolete
2602        if ((mContentWidth | mContentHeight) == 0) {
2603            return;
2604        }
2605
2606        if (mHeightCanMeasure) {
2607            if (getMeasuredHeight() != contentToViewDimension(mContentHeight)
2608                    && updateLayout) {
2609                requestLayout();
2610            }
2611        } else if (mWidthCanMeasure) {
2612            if (getMeasuredWidth() != contentToViewDimension(mContentWidth)
2613                    && updateLayout) {
2614                requestLayout();
2615            }
2616        } else {
2617            // If we don't request a layout, try to send our view size to the
2618            // native side to ensure that WebCore has the correct dimensions.
2619            sendViewSizeZoom();
2620        }
2621    }
2622
2623    /**
2624     * Set the WebViewClient that will receive various notifications and
2625     * requests. This will replace the current handler.
2626     * @param client An implementation of WebViewClient.
2627     */
2628    public void setWebViewClient(WebViewClient client) {
2629        mCallbackProxy.setWebViewClient(client);
2630    }
2631
2632    /**
2633     * Register the interface to be used when content can not be handled by
2634     * the rendering engine, and should be downloaded instead. This will replace
2635     * the current handler.
2636     * @param listener An implementation of DownloadListener.
2637     */
2638    public void setDownloadListener(DownloadListener listener) {
2639        mCallbackProxy.setDownloadListener(listener);
2640    }
2641
2642    /**
2643     * Set the chrome handler. This is an implementation of WebChromeClient for
2644     * use in handling Javascript dialogs, favicons, titles, and the progress.
2645     * This will replace the current handler.
2646     * @param client An implementation of WebChromeClient.
2647     */
2648    public void setWebChromeClient(WebChromeClient client) {
2649        mCallbackProxy.setWebChromeClient(client);
2650    }
2651
2652    /**
2653     * Gets the chrome handler.
2654     * @return the current WebChromeClient instance.
2655     *
2656     * @hide API council approval.
2657     */
2658    public WebChromeClient getWebChromeClient() {
2659        return mCallbackProxy.getWebChromeClient();
2660    }
2661
2662    /**
2663     * Set the Picture listener. This is an interface used to receive
2664     * notifications of a new Picture.
2665     * @param listener An implementation of WebView.PictureListener.
2666     */
2667    public void setPictureListener(PictureListener listener) {
2668        mPictureListener = listener;
2669    }
2670
2671    /**
2672     * {@hide}
2673     */
2674    /* FIXME: Debug only! Remove for SDK! */
2675    public void externalRepresentation(Message callback) {
2676        mWebViewCore.sendMessage(EventHub.REQUEST_EXT_REPRESENTATION, callback);
2677    }
2678
2679    /**
2680     * {@hide}
2681     */
2682    /* FIXME: Debug only! Remove for SDK! */
2683    public void documentAsText(Message callback) {
2684        mWebViewCore.sendMessage(EventHub.REQUEST_DOC_AS_TEXT, callback);
2685    }
2686
2687    /**
2688     * Use this function to bind an object to Javascript so that the
2689     * methods can be accessed from Javascript.
2690     * <p><strong>IMPORTANT:</strong>
2691     * <ul>
2692     * <li> Using addJavascriptInterface() allows JavaScript to control your
2693     * application. This can be a very useful feature or a dangerous security
2694     * issue. When the HTML in the WebView is untrustworthy (for example, part
2695     * or all of the HTML is provided by some person or process), then an
2696     * attacker could inject HTML that will execute your code and possibly any
2697     * code of the attacker's choosing.<br>
2698     * Do not use addJavascriptInterface() unless all of the HTML in this
2699     * WebView was written by you.</li>
2700     * <li> The Java object that is bound runs in another thread and not in
2701     * the thread that it was constructed in.</li>
2702     * </ul></p>
2703     * @param obj The class instance to bind to Javascript
2704     * @param interfaceName The name to used to expose the class in Javascript
2705     */
2706    public void addJavascriptInterface(Object obj, String interfaceName) {
2707        WebViewCore.JSInterfaceData arg = new WebViewCore.JSInterfaceData();
2708        arg.mObject = obj;
2709        arg.mInterfaceName = interfaceName;
2710        mWebViewCore.sendMessage(EventHub.ADD_JS_INTERFACE, arg);
2711    }
2712
2713    /**
2714     * Return the WebSettings object used to control the settings for this
2715     * WebView.
2716     * @return A WebSettings object that can be used to control this WebView's
2717     *         settings.
2718     */
2719    public WebSettings getSettings() {
2720        return mWebViewCore.getSettings();
2721    }
2722
2723   /**
2724    * Return the list of currently loaded plugins.
2725    * @return The list of currently loaded plugins.
2726    *
2727    * @deprecated This was used for Gears, which has been deprecated.
2728    */
2729    @Deprecated
2730    public static synchronized PluginList getPluginList() {
2731        return null;
2732    }
2733
2734   /**
2735    * @deprecated This was used for Gears, which has been deprecated.
2736    */
2737    @Deprecated
2738    public void refreshPlugins(boolean reloadOpenPages) { }
2739
2740    //-------------------------------------------------------------------------
2741    // Override View methods
2742    //-------------------------------------------------------------------------
2743
2744    @Override
2745    protected void finalize() throws Throwable {
2746        try {
2747            destroy();
2748        } finally {
2749            super.finalize();
2750        }
2751    }
2752
2753    @Override
2754    protected boolean drawChild(Canvas canvas, View child, long drawingTime) {
2755        if (child == mTitleBar) {
2756            // When drawing the title bar, move it horizontally to always show
2757            // at the top of the WebView.
2758            mTitleBar.offsetLeftAndRight(mScrollX - mTitleBar.getLeft());
2759        }
2760        return super.drawChild(canvas, child, drawingTime);
2761    }
2762
2763    @Override
2764    protected void onDraw(Canvas canvas) {
2765        // if mNativeClass is 0, the WebView has been destroyed. Do nothing.
2766        if (mNativeClass == 0) {
2767            return;
2768        }
2769        int saveCount = canvas.save();
2770        if (mTitleBar != null) {
2771            canvas.translate(0, (int) mTitleBar.getHeight());
2772        }
2773        // Update the buttons in the picture, so when we draw the picture
2774        // to the screen, they are in the correct state.
2775        // Tell the native side if user is a) touching the screen,
2776        // b) pressing the trackball down, or c) pressing the enter key
2777        // If the cursor is on a button, we need to draw it in the pressed
2778        // state.
2779        // If mNativeClass is 0, we should not reach here, so we do not
2780        // need to check it again.
2781        nativeRecordButtons(hasFocus() && hasWindowFocus(),
2782                mTouchMode == TOUCH_SHORTPRESS_START_MODE
2783                || mTrackballDown || mGotCenterDown, false);
2784        drawCoreAndCursorRing(canvas, mBackgroundColor, mDrawCursorRing);
2785        canvas.restoreToCount(saveCount);
2786
2787        // Now draw the shadow.
2788        if (mTitleBar != null) {
2789            int y = mScrollY + getVisibleTitleHeight();
2790            int height = (int) (5f * getContext().getResources()
2791                    .getDisplayMetrics().density);
2792            mTitleShadow.setBounds(mScrollX, y, mScrollX + getWidth(),
2793                    y + height);
2794            mTitleShadow.draw(canvas);
2795        }
2796        if (AUTO_REDRAW_HACK && mAutoRedraw) {
2797            invalidate();
2798        }
2799    }
2800
2801    @Override
2802    public void setLayoutParams(ViewGroup.LayoutParams params) {
2803        if (params.height == LayoutParams.WRAP_CONTENT) {
2804            mWrapContent = true;
2805        }
2806        super.setLayoutParams(params);
2807    }
2808
2809    @Override
2810    public boolean performLongClick() {
2811        if (mNativeClass != 0 && nativeCursorIsTextInput()) {
2812            // Send the click so that the textfield is in focus
2813            // FIXME: When we start respecting changes to the native textfield's
2814            // selection, need to make sure that this does not change it.
2815            mWebViewCore.sendMessage(EventHub.CLICK, nativeCursorFramePointer(),
2816                    nativeCursorNodePointer());
2817            rebuildWebTextView();
2818        }
2819        if (inEditingMode()) {
2820            return mWebTextView.performLongClick();
2821        } else {
2822            return super.performLongClick();
2823        }
2824    }
2825
2826    boolean inAnimateZoom() {
2827        return mZoomScale != 0;
2828    }
2829
2830    /**
2831     * Need to adjust the WebTextView after a change in zoom, since mActualScale
2832     * has changed.  This is especially important for password fields, which are
2833     * drawn by the WebTextView, since it conveys more information than what
2834     * webkit draws.  Thus we need to reposition it to show in the correct
2835     * place.
2836     */
2837    private boolean mNeedToAdjustWebTextView;
2838
2839    private void drawCoreAndCursorRing(Canvas canvas, int color,
2840        boolean drawCursorRing) {
2841        if (mDrawHistory) {
2842            canvas.scale(mActualScale, mActualScale);
2843            canvas.drawPicture(mHistoryPicture);
2844            return;
2845        }
2846
2847        boolean animateZoom = mZoomScale != 0;
2848        boolean animateScroll = !mScroller.isFinished()
2849                || mVelocityTracker != null;
2850        if (animateZoom) {
2851            float zoomScale;
2852            int interval = (int) (SystemClock.uptimeMillis() - mZoomStart);
2853            if (interval < ZOOM_ANIMATION_LENGTH) {
2854                float ratio = (float) interval / ZOOM_ANIMATION_LENGTH;
2855                zoomScale = 1.0f / (mInvInitialZoomScale
2856                        + (mInvFinalZoomScale - mInvInitialZoomScale) * ratio);
2857                invalidate();
2858            } else {
2859                zoomScale = mZoomScale;
2860                // set mZoomScale to be 0 as we have done animation
2861                mZoomScale = 0;
2862                // call invalidate() again to draw with the final filters
2863                invalidate();
2864                if (mNeedToAdjustWebTextView) {
2865                    mNeedToAdjustWebTextView = false;
2866                    Rect contentBounds = nativeFocusCandidateNodeBounds();
2867                    Rect vBox = contentToViewRect(contentBounds);
2868                    Rect visibleRect = new Rect();
2869                    calcOurVisibleRect(visibleRect);
2870                    if (visibleRect.contains(vBox)) {
2871                        // As a result of the zoom, the textfield is now on
2872                        // screen.  Place the WebTextView in its new place,
2873                        // accounting for our new scroll/zoom values.
2874                        mWebTextView.setTextSize(TypedValue.COMPLEX_UNIT_PX,
2875                                contentToViewDimension(
2876                                nativeFocusCandidateTextSize()));
2877                        mWebTextView.setRect(vBox.left, vBox.top, vBox.width(),
2878                                vBox.height());
2879                        // If it is a password field, start drawing the
2880                        // WebTextView once again.
2881                        if (nativeFocusCandidateIsPassword()) {
2882                            mWebTextView.setInPassword(true);
2883                        }
2884                    } else {
2885                        // The textfield is now off screen.  The user probably
2886                        // was not zooming to see the textfield better.  Remove
2887                        // the WebTextView.  If the user types a key, and the
2888                        // textfield is still in focus, we will reconstruct
2889                        // the WebTextView and scroll it back on screen.
2890                        mWebTextView.remove();
2891                    }
2892                }
2893            }
2894            // calculate the intermediate scroll position. As we need to use
2895            // zoomScale, we can't use pinLocX/Y directly. Copy the logic here.
2896            float scale = zoomScale * mInvInitialZoomScale;
2897            int tx = Math.round(scale * (mInitialScrollX + mZoomCenterX)
2898                    - mZoomCenterX);
2899            tx = -pinLoc(tx, getViewWidth(), Math.round(mContentWidth
2900                    * zoomScale)) + mScrollX;
2901            int titleHeight = getTitleHeight();
2902            int ty = Math.round(scale
2903                    * (mInitialScrollY + mZoomCenterY - titleHeight)
2904                    - (mZoomCenterY - titleHeight));
2905            ty = -(ty <= titleHeight ? Math.max(ty, 0) : pinLoc(ty
2906                    - titleHeight, getViewHeight(), Math.round(mContentHeight
2907                    * zoomScale)) + titleHeight) + mScrollY;
2908            canvas.translate(tx, ty);
2909            canvas.scale(zoomScale, zoomScale);
2910            if (inEditingMode() && !mNeedToAdjustWebTextView
2911                    && mZoomScale != 0) {
2912                // The WebTextView is up.  Keep track of this so we can adjust
2913                // its size and placement when we finish zooming
2914                mNeedToAdjustWebTextView = true;
2915                // If it is in password mode, turn it off so it does not draw
2916                // misplaced.
2917                if (nativeFocusCandidateIsPassword()) {
2918                    mWebTextView.setInPassword(false);
2919                }
2920            }
2921        } else {
2922            canvas.scale(mActualScale, mActualScale);
2923        }
2924
2925        mWebViewCore.drawContentPicture(canvas, color, animateZoom,
2926                animateScroll);
2927
2928        if (mNativeClass == 0) return;
2929        if (mShiftIsPressed && !animateZoom) {
2930            if (mTouchSelection) {
2931                nativeDrawSelectionRegion(canvas);
2932            } else {
2933                nativeDrawSelection(canvas, mInvActualScale, getTitleHeight(),
2934                        mSelectX, mSelectY, mExtendSelection);
2935            }
2936        } else if (drawCursorRing) {
2937            if (mTouchMode == TOUCH_SHORTPRESS_START_MODE) {
2938                mTouchMode = TOUCH_SHORTPRESS_MODE;
2939                HitTestResult hitTest = getHitTestResult();
2940                if (hitTest != null &&
2941                        hitTest.mType != HitTestResult.UNKNOWN_TYPE) {
2942                    mPrivateHandler.sendMessageDelayed(mPrivateHandler
2943                            .obtainMessage(SWITCH_TO_LONGPRESS),
2944                            LONG_PRESS_TIMEOUT);
2945                }
2946            }
2947            nativeDrawCursorRing(canvas);
2948        }
2949        // When the FindDialog is up, only draw the matches if we are not in
2950        // the process of scrolling them into view.
2951        if (mFindIsUp && !animateScroll) {
2952            nativeDrawMatches(canvas);
2953        }
2954    }
2955
2956    // draw history
2957    private boolean mDrawHistory = false;
2958    private Picture mHistoryPicture = null;
2959    private int mHistoryWidth = 0;
2960    private int mHistoryHeight = 0;
2961
2962    // Only check the flag, can be called from WebCore thread
2963    boolean drawHistory() {
2964        return mDrawHistory;
2965    }
2966
2967    // Should only be called in UI thread
2968    void switchOutDrawHistory() {
2969        if (null == mWebViewCore) return; // CallbackProxy may trigger this
2970        if (mDrawHistory && mWebViewCore.pictureReady()) {
2971            mDrawHistory = false;
2972            invalidate();
2973            int oldScrollX = mScrollX;
2974            int oldScrollY = mScrollY;
2975            mScrollX = pinLocX(mScrollX);
2976            mScrollY = pinLocY(mScrollY);
2977            if (oldScrollX != mScrollX || oldScrollY != mScrollY) {
2978                mUserScroll = false;
2979                mWebViewCore.sendMessage(EventHub.SYNC_SCROLL, oldScrollX,
2980                        oldScrollY);
2981            }
2982            sendOurVisibleRect();
2983        }
2984    }
2985
2986    WebViewCore.CursorData cursorData() {
2987        WebViewCore.CursorData result = new WebViewCore.CursorData();
2988        result.mMoveGeneration = nativeMoveGeneration();
2989        result.mFrame = nativeCursorFramePointer();
2990        Point position = nativeCursorPosition();
2991        result.mX = position.x;
2992        result.mY = position.y;
2993        return result;
2994    }
2995
2996    /**
2997     *  Delete text from start to end in the focused textfield. If there is no
2998     *  focus, or if start == end, silently fail.  If start and end are out of
2999     *  order, swap them.
3000     *  @param  start   Beginning of selection to delete.
3001     *  @param  end     End of selection to delete.
3002     */
3003    /* package */ void deleteSelection(int start, int end) {
3004        mTextGeneration++;
3005        WebViewCore.TextSelectionData data
3006                = new WebViewCore.TextSelectionData(start, end);
3007        mWebViewCore.sendMessage(EventHub.DELETE_SELECTION, mTextGeneration, 0,
3008                data);
3009    }
3010
3011    /**
3012     *  Set the selection to (start, end) in the focused textfield. If start and
3013     *  end are out of order, swap them.
3014     *  @param  start   Beginning of selection.
3015     *  @param  end     End of selection.
3016     */
3017    /* package */ void setSelection(int start, int end) {
3018        mWebViewCore.sendMessage(EventHub.SET_SELECTION, start, end);
3019    }
3020
3021    // Called by JNI when a touch event puts a textfield into focus.
3022    private void displaySoftKeyboard(boolean isTextView) {
3023        InputMethodManager imm = (InputMethodManager)
3024                getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
3025
3026        if (isTextView) {
3027            if (mWebTextView == null) return;
3028
3029            imm.showSoftInput(mWebTextView, 0);
3030            if (mInZoomOverview) {
3031                // if in zoom overview mode, call doDoubleTap() to bring it back
3032                // to normal mode so that user can enter text.
3033                doDoubleTap();
3034            }
3035        }
3036        else { // used by plugins
3037            imm.showSoftInput(this, 0);
3038        }
3039    }
3040
3041    // Called by WebKit to instruct the UI to hide the keyboard
3042    private void hideSoftKeyboard() {
3043        InputMethodManager imm = (InputMethodManager)
3044                getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
3045
3046        imm.hideSoftInputFromWindow(this.getWindowToken(), 0);
3047    }
3048
3049    /*
3050     * This method checks the current focus and cursor and potentially rebuilds
3051     * mWebTextView to have the appropriate properties, such as password,
3052     * multiline, and what text it contains.  It also removes it if necessary.
3053     */
3054    /* package */ void rebuildWebTextView() {
3055        // If the WebView does not have focus, do nothing until it gains focus.
3056        if (!hasFocus() && (null == mWebTextView || !mWebTextView.hasFocus())) {
3057            return;
3058        }
3059        boolean alreadyThere = inEditingMode();
3060        // inEditingMode can only return true if mWebTextView is non-null,
3061        // so we can safely call remove() if (alreadyThere)
3062        if (0 == mNativeClass || !nativeFocusCandidateIsTextInput()) {
3063            if (alreadyThere) {
3064                mWebTextView.remove();
3065            }
3066            return;
3067        }
3068        // At this point, we know we have found an input field, so go ahead
3069        // and create the WebTextView if necessary.
3070        if (mWebTextView == null) {
3071            mWebTextView = new WebTextView(mContext, WebView.this);
3072            // Initialize our generation number.
3073            mTextGeneration = 0;
3074        }
3075        mWebTextView.setTextSize(TypedValue.COMPLEX_UNIT_PX,
3076                contentToViewDimension(nativeFocusCandidateTextSize()));
3077        Rect visibleRect = new Rect();
3078        calcOurContentVisibleRect(visibleRect);
3079        // Note that sendOurVisibleRect calls viewToContent, so the coordinates
3080        // should be in content coordinates.
3081        Rect bounds = nativeFocusCandidateNodeBounds();
3082        if (!Rect.intersects(bounds, visibleRect)) {
3083            mWebTextView.bringIntoView();
3084        }
3085        String text = nativeFocusCandidateText();
3086        int nodePointer = nativeFocusCandidatePointer();
3087        if (alreadyThere && mWebTextView.isSameTextField(nodePointer)) {
3088            // It is possible that we have the same textfield, but it has moved,
3089            // i.e. In the case of opening/closing the screen.
3090            // In that case, we need to set the dimensions, but not the other
3091            // aspects.
3092            // We also need to restore the selection, which gets wrecked by
3093            // calling setTextEntryRect.
3094            Spannable spannable = (Spannable) mWebTextView.getText();
3095            int start = Selection.getSelectionStart(spannable);
3096            int end = Selection.getSelectionEnd(spannable);
3097            // If the text has been changed by webkit, update it.  However, if
3098            // there has been more UI text input, ignore it.  We will receive
3099            // another update when that text is recognized.
3100            if (text != null && !text.equals(spannable.toString())
3101                    && nativeTextGeneration() == mTextGeneration) {
3102                mWebTextView.setTextAndKeepSelection(text);
3103            } else {
3104                Selection.setSelection(spannable, start, end);
3105            }
3106        } else {
3107            Rect vBox = contentToViewRect(bounds);
3108            mWebTextView.setRect(vBox.left, vBox.top, vBox.width(),
3109                    vBox.height());
3110            mWebTextView.setGravity(nativeFocusCandidateIsRtlText() ?
3111                    Gravity.RIGHT : Gravity.NO_GRAVITY);
3112            // this needs to be called before update adapter thread starts to
3113            // ensure the mWebTextView has the same node pointer
3114            mWebTextView.setNodePointer(nodePointer);
3115            int maxLength = -1;
3116            boolean isTextField = nativeFocusCandidateIsTextField();
3117            if (isTextField) {
3118                maxLength = nativeFocusCandidateMaxLength();
3119                String name = nativeFocusCandidateName();
3120                if (mWebViewCore.getSettings().getSaveFormData()
3121                        && name != null) {
3122                    Message update = mPrivateHandler.obtainMessage(
3123                            REQUEST_FORM_DATA, nodePointer);
3124                    RequestFormData updater = new RequestFormData(name,
3125                            getUrl(), update);
3126                    Thread t = new Thread(updater);
3127                    t.start();
3128                }
3129            }
3130            mWebTextView.setMaxLength(maxLength);
3131            AutoCompleteAdapter adapter = null;
3132            mWebTextView.setAdapterCustom(adapter);
3133            mWebTextView.setSingleLine(isTextField);
3134            mWebTextView.setInPassword(nativeFocusCandidateIsPassword());
3135            if (null == text) {
3136                mWebTextView.setText("", 0, 0);
3137                if (DebugFlags.WEB_VIEW) {
3138                    Log.v(LOGTAG, "rebuildWebTextView null == text");
3139                }
3140            } else {
3141                // Change to true to enable the old style behavior, where
3142                // entering a textfield/textarea always set the selection to the
3143                // whole field.  This was desirable for the case where the user
3144                // intends to scroll past the field using the trackball.
3145                // However, it causes a problem when replying to emails - the
3146                // user expects the cursor to be at the beginning of the
3147                // textarea.  Testing out a new behavior, where textfields set
3148                // selection at the end, and textareas at the beginning.
3149                if (false) {
3150                    mWebTextView.setText(text, 0, text.length());
3151                } else if (isTextField) {
3152                    int length = text.length();
3153                    mWebTextView.setText(text, length, length);
3154                    if (DebugFlags.WEB_VIEW) {
3155                        Log.v(LOGTAG, "rebuildWebTextView length=" + length);
3156                    }
3157                } else {
3158                    mWebTextView.setText(text, 0, 0);
3159                    if (DebugFlags.WEB_VIEW) {
3160                        Log.v(LOGTAG, "rebuildWebTextView !isTextField");
3161                    }
3162                }
3163            }
3164            mWebTextView.requestFocus();
3165        }
3166    }
3167
3168    /*
3169     * This class requests an Adapter for the WebTextView which shows past
3170     * entries stored in the database.  It is a Runnable so that it can be done
3171     * in its own thread, without slowing down the UI.
3172     */
3173    private class RequestFormData implements Runnable {
3174        private String mName;
3175        private String mUrl;
3176        private Message mUpdateMessage;
3177
3178        public RequestFormData(String name, String url, Message msg) {
3179            mName = name;
3180            mUrl = url;
3181            mUpdateMessage = msg;
3182        }
3183
3184        public void run() {
3185            ArrayList<String> pastEntries = mDatabase.getFormData(mUrl, mName);
3186            if (pastEntries.size() > 0) {
3187                AutoCompleteAdapter adapter = new
3188                        AutoCompleteAdapter(mContext, pastEntries);
3189                mUpdateMessage.obj = adapter;
3190                mUpdateMessage.sendToTarget();
3191            }
3192        }
3193    }
3194
3195    // This is used to determine long press with the center key.  Does not
3196    // affect long press with the trackball/touch.
3197    private boolean mGotCenterDown = false;
3198
3199    @Override
3200    public boolean onKeyDown(int keyCode, KeyEvent event) {
3201        if (DebugFlags.WEB_VIEW) {
3202            Log.v(LOGTAG, "keyDown at " + System.currentTimeMillis()
3203                    + ", " + event + ", unicode=" + event.getUnicodeChar());
3204        }
3205
3206        if (mNativeClass == 0) {
3207            return false;
3208        }
3209
3210        // do this hack up front, so it always works, regardless of touch-mode
3211        if (AUTO_REDRAW_HACK && (keyCode == KeyEvent.KEYCODE_CALL)) {
3212            mAutoRedraw = !mAutoRedraw;
3213            if (mAutoRedraw) {
3214                invalidate();
3215            }
3216            return true;
3217        }
3218
3219        // Bubble up the key event if
3220        // 1. it is a system key; or
3221        // 2. the host application wants to handle it;
3222        if (event.isSystem()
3223                || mCallbackProxy.uiOverrideKeyEvent(event)) {
3224            return false;
3225        }
3226
3227        if (mShiftIsPressed == false && nativeCursorWantsKeyEvents() == false
3228                && (keyCode == KeyEvent.KEYCODE_SHIFT_LEFT
3229                || keyCode == KeyEvent.KEYCODE_SHIFT_RIGHT)) {
3230            mExtendSelection = false;
3231            mShiftIsPressed = true;
3232            if (nativeHasCursorNode()) {
3233                Rect rect = nativeCursorNodeBounds();
3234                mSelectX = contentToViewX(rect.left);
3235                mSelectY = contentToViewY(rect.top);
3236            } else {
3237                mSelectX = mScrollX + (int) mLastTouchX;
3238                mSelectY = mScrollY + (int) mLastTouchY;
3239            }
3240            nativeHideCursor();
3241       }
3242
3243        if (keyCode >= KeyEvent.KEYCODE_DPAD_UP
3244                && keyCode <= KeyEvent.KEYCODE_DPAD_RIGHT) {
3245            // always handle the navigation keys in the UI thread
3246            switchOutDrawHistory();
3247            if (navHandledKey(keyCode, 1, false, event.getEventTime(), false)) {
3248                playSoundEffect(keyCodeToSoundsEffect(keyCode));
3249                return true;
3250            }
3251            // Bubble up the key event as WebView doesn't handle it
3252            return false;
3253        }
3254
3255        if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER) {
3256            switchOutDrawHistory();
3257            if (event.getRepeatCount() == 0) {
3258                mGotCenterDown = true;
3259                mPrivateHandler.sendMessageDelayed(mPrivateHandler
3260                        .obtainMessage(LONG_PRESS_CENTER), LONG_PRESS_TIMEOUT);
3261                // Already checked mNativeClass, so we do not need to check it
3262                // again.
3263                nativeRecordButtons(hasFocus() && hasWindowFocus(), true, true);
3264                return true;
3265            }
3266            // Bubble up the key event as WebView doesn't handle it
3267            return false;
3268        }
3269
3270        if (keyCode != KeyEvent.KEYCODE_SHIFT_LEFT
3271                && keyCode != KeyEvent.KEYCODE_SHIFT_RIGHT) {
3272            // turn off copy select if a shift-key combo is pressed
3273            mExtendSelection = mShiftIsPressed = false;
3274            if (mTouchMode == TOUCH_SELECT_MODE) {
3275                mTouchMode = TOUCH_INIT_MODE;
3276            }
3277        }
3278
3279        if (getSettings().getNavDump()) {
3280            switch (keyCode) {
3281                case KeyEvent.KEYCODE_4:
3282                    // "/data/data/com.android.browser/displayTree.txt"
3283                    nativeDumpDisplayTree(getUrl());
3284                    break;
3285                case KeyEvent.KEYCODE_5:
3286                case KeyEvent.KEYCODE_6:
3287                    // 5: dump the dom tree to the file
3288                    // "/data/data/com.android.browser/domTree.txt"
3289                    // 6: dump the dom tree to the adb log
3290                    mWebViewCore.sendMessage(EventHub.DUMP_DOMTREE,
3291                            (keyCode == KeyEvent.KEYCODE_5) ? 1 : 0, 0);
3292                    break;
3293                case KeyEvent.KEYCODE_7:
3294                case KeyEvent.KEYCODE_8:
3295                    // 7: dump the render tree to the file
3296                    // "/data/data/com.android.browser/renderTree.txt"
3297                    // 8: dump the render tree to the adb log
3298                    mWebViewCore.sendMessage(EventHub.DUMP_RENDERTREE,
3299                            (keyCode == KeyEvent.KEYCODE_7) ? 1 : 0, 0);
3300                    break;
3301                case KeyEvent.KEYCODE_9:
3302                    nativeInstrumentReport();
3303                    return true;
3304            }
3305        }
3306
3307        if (nativeCursorIsPlugin()) {
3308            nativeUpdatePluginReceivesEvents();
3309            invalidate();
3310        } else if (nativeCursorIsTextInput()) {
3311            // This message will put the node in focus, for the DOM's notion
3312            // of focus, and make the focuscontroller active
3313            mWebViewCore.sendMessage(EventHub.CLICK, nativeCursorFramePointer(),
3314                    nativeCursorNodePointer());
3315            // This will bring up the WebTextView and put it in focus, for
3316            // our view system's notion of focus
3317            rebuildWebTextView();
3318            // Now we need to pass the event to it
3319            return mWebTextView.onKeyDown(keyCode, event);
3320        } else if (nativeHasFocusNode()) {
3321            // In this case, the cursor is not on a text input, but the focus
3322            // might be.  Check it, and if so, hand over to the WebTextView.
3323            rebuildWebTextView();
3324            if (inEditingMode()) {
3325                return mWebTextView.onKeyDown(keyCode, event);
3326            }
3327        }
3328
3329        // TODO: should we pass all the keys to DOM or check the meta tag
3330        if (nativeCursorWantsKeyEvents() || true) {
3331            // pass the key to DOM
3332            mWebViewCore.sendMessage(EventHub.KEY_DOWN, event);
3333            // return true as DOM handles the key
3334            return true;
3335        }
3336
3337        // Bubble up the key event as WebView doesn't handle it
3338        return false;
3339    }
3340
3341    @Override
3342    public boolean onKeyUp(int keyCode, KeyEvent event) {
3343        if (DebugFlags.WEB_VIEW) {
3344            Log.v(LOGTAG, "keyUp at " + System.currentTimeMillis()
3345                    + ", " + event + ", unicode=" + event.getUnicodeChar());
3346        }
3347
3348        if (mNativeClass == 0) {
3349            return false;
3350        }
3351
3352        // special CALL handling when cursor node's href is "tel:XXX"
3353        if (keyCode == KeyEvent.KEYCODE_CALL && nativeHasCursorNode()) {
3354            String text = nativeCursorText();
3355            if (!nativeCursorIsTextInput() && text != null
3356                    && text.startsWith(SCHEME_TEL)) {
3357                Intent intent = new Intent(Intent.ACTION_DIAL, Uri.parse(text));
3358                getContext().startActivity(intent);
3359                return true;
3360            }
3361        }
3362
3363        // Bubble up the key event if
3364        // 1. it is a system key; or
3365        // 2. the host application wants to handle it;
3366        if (event.isSystem() || mCallbackProxy.uiOverrideKeyEvent(event)) {
3367            return false;
3368        }
3369
3370        if (keyCode == KeyEvent.KEYCODE_SHIFT_LEFT
3371                || keyCode == KeyEvent.KEYCODE_SHIFT_RIGHT) {
3372            if (commitCopy()) {
3373                return true;
3374            }
3375        }
3376
3377        if (keyCode >= KeyEvent.KEYCODE_DPAD_UP
3378                && keyCode <= KeyEvent.KEYCODE_DPAD_RIGHT) {
3379            // always handle the navigation keys in the UI thread
3380            // Bubble up the key event as WebView doesn't handle it
3381            return false;
3382        }
3383
3384        if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER) {
3385            // remove the long press message first
3386            mPrivateHandler.removeMessages(LONG_PRESS_CENTER);
3387            mGotCenterDown = false;
3388
3389            if (mShiftIsPressed) {
3390                return false;
3391            }
3392
3393            // perform the single click
3394            Rect visibleRect = sendOurVisibleRect();
3395            // Note that sendOurVisibleRect calls viewToContent, so the
3396            // coordinates should be in content coordinates.
3397            if (!nativeCursorIntersects(visibleRect)) {
3398                return false;
3399            }
3400            nativeSetFollowedLink(true);
3401            nativeUpdatePluginReceivesEvents();
3402            WebViewCore.CursorData data = cursorData();
3403            mWebViewCore.sendMessage(EventHub.SET_MOVE_MOUSE, data);
3404            playSoundEffect(SoundEffectConstants.CLICK);
3405            boolean isTextInput = nativeCursorIsTextInput();
3406            if (isTextInput || !mCallbackProxy.uiOverrideUrlLoading(
3407                        nativeCursorText())) {
3408                mWebViewCore.sendMessage(EventHub.CLICK, data.mFrame,
3409                        nativeCursorNodePointer());
3410            }
3411            if (isTextInput) {
3412                rebuildWebTextView();
3413                displaySoftKeyboard(true);
3414            }
3415            return true;
3416        }
3417
3418        // TODO: should we pass all the keys to DOM or check the meta tag
3419        if (nativeCursorWantsKeyEvents() || true) {
3420            // pass the key to DOM
3421            mWebViewCore.sendMessage(EventHub.KEY_UP, event);
3422            // return true as DOM handles the key
3423            return true;
3424        }
3425
3426        // Bubble up the key event as WebView doesn't handle it
3427        return false;
3428    }
3429
3430    /**
3431     * @hide
3432     */
3433    public void emulateShiftHeld() {
3434        mExtendSelection = false;
3435        mShiftIsPressed = true;
3436        nativeHideCursor();
3437    }
3438
3439    private boolean commitCopy() {
3440        boolean copiedSomething = false;
3441        if (mExtendSelection) {
3442            // copy region so core operates on copy without touching orig.
3443            Region selection = new Region(nativeGetSelection());
3444            if (selection.isEmpty() == false) {
3445                Toast.makeText(mContext
3446                        , com.android.internal.R.string.text_copied
3447                        , Toast.LENGTH_SHORT).show();
3448                mWebViewCore.sendMessage(EventHub.GET_SELECTION, selection);
3449                copiedSomething = true;
3450            }
3451            mExtendSelection = false;
3452        }
3453        mShiftIsPressed = false;
3454        if (mTouchMode == TOUCH_SELECT_MODE) {
3455            mTouchMode = TOUCH_INIT_MODE;
3456        }
3457        return copiedSomething;
3458    }
3459
3460    // Set this as a hierarchy change listener so we can know when this view
3461    // is removed and still have access to our parent.
3462    @Override
3463    protected void onAttachedToWindow() {
3464        super.onAttachedToWindow();
3465        ViewParent parent = getParent();
3466        if (parent instanceof ViewGroup) {
3467            ViewGroup p = (ViewGroup) parent;
3468            p.setOnHierarchyChangeListener(this);
3469        }
3470    }
3471
3472    @Override
3473    protected void onDetachedFromWindow() {
3474        super.onDetachedFromWindow();
3475        ViewParent parent = getParent();
3476        if (parent instanceof ViewGroup) {
3477            ViewGroup p = (ViewGroup) parent;
3478            p.setOnHierarchyChangeListener(null);
3479        }
3480
3481        // Clean up the zoom controller
3482        mZoomButtonsController.setVisible(false);
3483    }
3484
3485    // Implementation for OnHierarchyChangeListener
3486    public void onChildViewAdded(View parent, View child) {}
3487
3488    public void onChildViewRemoved(View p, View child) {
3489        if (child == this) {
3490            clearTextEntry();
3491        }
3492    }
3493
3494    /**
3495     * @deprecated WebView should not have implemented
3496     * ViewTreeObserver.OnGlobalFocusChangeListener.  This method
3497     * does nothing now.
3498     */
3499    @Deprecated
3500    public void onGlobalFocusChanged(View oldFocus, View newFocus) {
3501    }
3502
3503    // To avoid drawing the cursor ring, and remove the TextView when our window
3504    // loses focus.
3505    @Override
3506    public void onWindowFocusChanged(boolean hasWindowFocus) {
3507        if (hasWindowFocus) {
3508            if (hasFocus()) {
3509                // If our window regained focus, and we have focus, then begin
3510                // drawing the cursor ring
3511                mDrawCursorRing = true;
3512                if (mNativeClass != 0) {
3513                    nativeRecordButtons(true, false, true);
3514                    if (inEditingMode()) {
3515                        mWebViewCore.sendMessage(EventHub.SET_ACTIVE, 1, 0);
3516                    }
3517                }
3518            } else {
3519                // If our window gained focus, but we do not have it, do not
3520                // draw the cursor ring.
3521                mDrawCursorRing = false;
3522                // We do not call nativeRecordButtons here because we assume
3523                // that when we lost focus, or window focus, it got called with
3524                // false for the first parameter
3525            }
3526        } else {
3527            if (getSettings().getBuiltInZoomControls() && !mZoomButtonsController.isVisible()) {
3528                /*
3529                 * The zoom controls come in their own window, so our window
3530                 * loses focus. Our policy is to not draw the cursor ring if
3531                 * our window is not focused, but this is an exception since
3532                 * the user can still navigate the web page with the zoom
3533                 * controls showing.
3534                 */
3535                // If our window has lost focus, stop drawing the cursor ring
3536                mDrawCursorRing = false;
3537            }
3538            mGotKeyDown = false;
3539            mShiftIsPressed = false;
3540            if (mNativeClass != 0) {
3541                nativeRecordButtons(false, false, true);
3542            }
3543            setFocusControllerInactive();
3544        }
3545        invalidate();
3546        super.onWindowFocusChanged(hasWindowFocus);
3547    }
3548
3549    /*
3550     * Pass a message to WebCore Thread, telling the WebCore::Page's
3551     * FocusController to be  "inactive" so that it will
3552     * not draw the blinking cursor.  It gets set to "active" to draw the cursor
3553     * in WebViewCore.cpp, when the WebCore thread receives key events/clicks.
3554     */
3555    /* package */ void setFocusControllerInactive() {
3556        // Do not need to also check whether mWebViewCore is null, because
3557        // mNativeClass is only set if mWebViewCore is non null
3558        if (mNativeClass == 0) return;
3559        mWebViewCore.sendMessage(EventHub.SET_ACTIVE, 0, 0);
3560    }
3561
3562    @Override
3563    protected void onFocusChanged(boolean focused, int direction,
3564            Rect previouslyFocusedRect) {
3565        if (DebugFlags.WEB_VIEW) {
3566            Log.v(LOGTAG, "MT focusChanged " + focused + ", " + direction);
3567        }
3568        if (focused) {
3569            // When we regain focus, if we have window focus, resume drawing
3570            // the cursor ring
3571            if (hasWindowFocus()) {
3572                mDrawCursorRing = true;
3573                if (mNativeClass != 0) {
3574                    nativeRecordButtons(true, false, true);
3575                }
3576            //} else {
3577                // The WebView has gained focus while we do not have
3578                // windowfocus.  When our window lost focus, we should have
3579                // called nativeRecordButtons(false...)
3580            }
3581        } else {
3582            // When we lost focus, unless focus went to the TextView (which is
3583            // true if we are in editing mode), stop drawing the cursor ring.
3584            if (!inEditingMode()) {
3585                mDrawCursorRing = false;
3586                if (mNativeClass != 0) {
3587                    nativeRecordButtons(false, false, true);
3588                }
3589                setFocusControllerInactive();
3590            }
3591            mGotKeyDown = false;
3592        }
3593
3594        super.onFocusChanged(focused, direction, previouslyFocusedRect);
3595    }
3596
3597    @Override
3598    protected void onSizeChanged(int w, int h, int ow, int oh) {
3599        super.onSizeChanged(w, h, ow, oh);
3600        // Center zooming to the center of the screen.
3601        if (mZoomScale == 0) { // unless we're already zooming
3602            mZoomCenterX = getViewWidth() * .5f;
3603            mZoomCenterY = getViewHeight() * .5f;
3604        }
3605
3606        // update mMinZoomScale if the minimum zoom scale is not fixed
3607        if (!mMinZoomScaleFixed) {
3608            // when change from narrow screen to wide screen, the new viewWidth
3609            // can be wider than the old content width. We limit the minimum
3610            // scale to 1.0f. The proper minimum scale will be calculated when
3611            // the new picture shows up.
3612            mMinZoomScale = Math.min(1.0f, (float) getViewWidth()
3613                    / (mDrawHistory ? mHistoryPicture.getWidth()
3614                            : mZoomOverviewWidth));
3615        }
3616
3617        // we always force, in case our height changed, in which case we still
3618        // want to send the notification over to webkit
3619        setNewZoomScale(mActualScale, true);
3620    }
3621
3622    @Override
3623    protected void onScrollChanged(int l, int t, int oldl, int oldt) {
3624        super.onScrollChanged(l, t, oldl, oldt);
3625
3626        sendOurVisibleRect();
3627    }
3628
3629
3630    @Override
3631    public boolean dispatchKeyEvent(KeyEvent event) {
3632        boolean dispatch = true;
3633
3634        if (!inEditingMode()) {
3635            if (event.getAction() == KeyEvent.ACTION_DOWN) {
3636                mGotKeyDown = true;
3637            } else {
3638                if (!mGotKeyDown) {
3639                    /*
3640                     * We got a key up for which we were not the recipient of
3641                     * the original key down. Don't give it to the view.
3642                     */
3643                    dispatch = false;
3644                }
3645                mGotKeyDown = false;
3646            }
3647        }
3648
3649        if (dispatch) {
3650            return super.dispatchKeyEvent(event);
3651        } else {
3652            // We didn't dispatch, so let something else handle the key
3653            return false;
3654        }
3655    }
3656
3657    // Here are the snap align logic:
3658    // 1. If it starts nearly horizontally or vertically, snap align;
3659    // 2. If there is a dramitic direction change, let it go;
3660    // 3. If there is a same direction back and forth, lock it.
3661
3662    // adjustable parameters
3663    private int mMinLockSnapReverseDistance;
3664    private static final float MAX_SLOPE_FOR_DIAG = 1.5f;
3665    private static final int MIN_BREAK_SNAP_CROSS_DISTANCE = 80;
3666
3667    @Override
3668    public boolean onTouchEvent(MotionEvent ev) {
3669        if (mNativeClass == 0 || !isClickable() || !isLongClickable()) {
3670            return false;
3671        }
3672
3673        if (DebugFlags.WEB_VIEW) {
3674            Log.v(LOGTAG, ev + " at " + ev.getEventTime() + " mTouchMode="
3675                    + mTouchMode);
3676        }
3677
3678        int action = ev.getAction();
3679        float x = ev.getX();
3680        float y = ev.getY();
3681        long eventTime = ev.getEventTime();
3682
3683        // Due to the touch screen edge effect, a touch closer to the edge
3684        // always snapped to the edge. As getViewWidth() can be different from
3685        // getWidth() due to the scrollbar, adjusting the point to match
3686        // getViewWidth(). Same applied to the height.
3687        if (x > getViewWidth() - 1) {
3688            x = getViewWidth() - 1;
3689        }
3690        if (y > getViewHeightWithTitle() - 1) {
3691            y = getViewHeightWithTitle() - 1;
3692        }
3693
3694        // pass the touch events from UI thread to WebCore thread
3695        if (mForwardTouchEvents && (action != MotionEvent.ACTION_MOVE
3696                || eventTime - mLastSentTouchTime > TOUCH_SENT_INTERVAL)) {
3697            WebViewCore.TouchEventData ted = new WebViewCore.TouchEventData();
3698            ted.mAction = action;
3699            ted.mX = viewToContentX((int) x + mScrollX);
3700            ted.mY = viewToContentY((int) y + mScrollY);
3701            mWebViewCore.sendMessage(EventHub.TOUCH_EVENT, ted);
3702            mLastSentTouchTime = eventTime;
3703        }
3704
3705        int deltaX = (int) (mLastTouchX - x);
3706        int deltaY = (int) (mLastTouchY - y);
3707
3708        switch (action) {
3709            case MotionEvent.ACTION_DOWN: {
3710                mPreventDrag = PREVENT_DRAG_NO;
3711                if (!mScroller.isFinished()) {
3712                    // stop the current scroll animation, but if this is
3713                    // the start of a fling, allow it to add to the current
3714                    // fling's velocity
3715                    mScroller.abortAnimation();
3716                    mTouchMode = TOUCH_DRAG_START_MODE;
3717                    mPrivateHandler.removeMessages(RESUME_WEBCORE_UPDATE);
3718                } else if (mShiftIsPressed) {
3719                    mSelectX = mScrollX + (int) x;
3720                    mSelectY = mScrollY + (int) y;
3721                    mTouchMode = TOUCH_SELECT_MODE;
3722                    if (DebugFlags.WEB_VIEW) {
3723                        Log.v(LOGTAG, "select=" + mSelectX + "," + mSelectY);
3724                    }
3725                    nativeMoveSelection(viewToContentX(mSelectX),
3726                            viewToContentY(mSelectY), false);
3727                    mTouchSelection = mExtendSelection = true;
3728                } else if (mPrivateHandler.hasMessages(RELEASE_SINGLE_TAP)) {
3729                    mPrivateHandler.removeMessages(RELEASE_SINGLE_TAP);
3730                    if (deltaX * deltaX + deltaY * deltaY < mDoubleTapSlopSquare) {
3731                        mTouchMode = TOUCH_DOUBLE_TAP_MODE;
3732                    } else {
3733                        // commit the short press action for the previous tap
3734                        doShortPress();
3735                        // continue, mTouchMode should be still TOUCH_INIT_MODE
3736                    }
3737                } else {
3738                    mTouchMode = TOUCH_INIT_MODE;
3739                    mPreventDrag = mForwardTouchEvents ? PREVENT_DRAG_MAYBE_YES
3740                            : PREVENT_DRAG_NO;
3741                    mWebViewCore.sendMessage(
3742                            EventHub.UPDATE_FRAME_CACHE_IF_LOADING);
3743                    if (mLogEvent && eventTime - mLastTouchUpTime < 1000) {
3744                        EventLog.writeEvent(EVENT_LOG_DOUBLE_TAP_DURATION,
3745                                (eventTime - mLastTouchUpTime), eventTime);
3746                    }
3747                }
3748                // Trigger the link
3749                if (mTouchMode == TOUCH_INIT_MODE
3750                        || mTouchMode == TOUCH_DOUBLE_TAP_MODE) {
3751                    mPrivateHandler.sendMessageDelayed(mPrivateHandler
3752                            .obtainMessage(SWITCH_TO_SHORTPRESS), TAP_TIMEOUT);
3753                }
3754                // Remember where the motion event started
3755                mLastTouchX = x;
3756                mLastTouchY = y;
3757                mLastTouchTime = eventTime;
3758                mVelocityTracker = VelocityTracker.obtain();
3759                mSnapScrollMode = SNAP_NONE;
3760                break;
3761            }
3762            case MotionEvent.ACTION_MOVE: {
3763                if (mTouchMode == TOUCH_DONE_MODE) {
3764                    // no dragging during scroll zoom animation
3765                    break;
3766                }
3767                mVelocityTracker.addMovement(ev);
3768
3769                if (mTouchMode != TOUCH_DRAG_MODE) {
3770                    if (mTouchMode == TOUCH_SELECT_MODE) {
3771                        mSelectX = mScrollX + (int) x;
3772                        mSelectY = mScrollY + (int) y;
3773                        if (DebugFlags.WEB_VIEW) {
3774                            Log.v(LOGTAG, "xtend=" + mSelectX + "," + mSelectY);
3775                        }
3776                        nativeMoveSelection(viewToContentX(mSelectX),
3777                               viewToContentY(mSelectY), true);
3778                        invalidate();
3779                        break;
3780                    }
3781                    if ((deltaX * deltaX + deltaY * deltaY) < mTouchSlopSquare) {
3782                        break;
3783                    }
3784                    if (mPreventDrag == PREVENT_DRAG_MAYBE_YES) {
3785                        // track mLastTouchTime as we may need to do fling at
3786                        // ACTION_UP
3787                        mLastTouchTime = eventTime;
3788                        break;
3789                    }
3790                    if (mTouchMode == TOUCH_SHORTPRESS_MODE
3791                            || mTouchMode == TOUCH_SHORTPRESS_START_MODE) {
3792                        mPrivateHandler.removeMessages(SWITCH_TO_LONGPRESS);
3793                    } else if (mTouchMode == TOUCH_INIT_MODE
3794                            || mTouchMode == TOUCH_DOUBLE_TAP_MODE) {
3795                        mPrivateHandler.removeMessages(SWITCH_TO_SHORTPRESS);
3796                    }
3797
3798                    // if it starts nearly horizontal or vertical, enforce it
3799                    int ax = Math.abs(deltaX);
3800                    int ay = Math.abs(deltaY);
3801                    if (ax > MAX_SLOPE_FOR_DIAG * ay) {
3802                        mSnapScrollMode = SNAP_X;
3803                        mSnapPositive = deltaX > 0;
3804                    } else if (ay > MAX_SLOPE_FOR_DIAG * ax) {
3805                        mSnapScrollMode = SNAP_Y;
3806                        mSnapPositive = deltaY > 0;
3807                    }
3808
3809                    mTouchMode = TOUCH_DRAG_MODE;
3810                    WebViewCore.pauseUpdate(mWebViewCore);
3811                    if (!mDragFromTextInput) {
3812                        nativeHideCursor();
3813                    }
3814                    WebSettings settings = getSettings();
3815                    if (settings.supportZoom()
3816                            && settings.getBuiltInZoomControls()
3817                            && !mZoomButtonsController.isVisible()
3818                            && mMinZoomScale < mMaxZoomScale) {
3819                        mZoomButtonsController.setVisible(true);
3820                        int count = settings.getDoubleTapToastCount();
3821                        if (mInZoomOverview && count > 0) {
3822                            settings.setDoubleTapToastCount(--count);
3823                            Toast.makeText(mContext,
3824                                    com.android.internal.R.string.double_tap_toast,
3825                                    Toast.LENGTH_LONG).show();
3826                        }
3827                    }
3828                }
3829
3830                // do pan
3831                int newScrollX = pinLocX(mScrollX + deltaX);
3832                deltaX = newScrollX - mScrollX;
3833                int newScrollY = pinLocY(mScrollY + deltaY);
3834                deltaY = newScrollY - mScrollY;
3835                boolean done = false;
3836                if (deltaX == 0 && deltaY == 0) {
3837                    done = true;
3838                } else {
3839                    if (mSnapScrollMode == SNAP_X || mSnapScrollMode == SNAP_Y) {
3840                        int ax = Math.abs(deltaX);
3841                        int ay = Math.abs(deltaY);
3842                        if (mSnapScrollMode == SNAP_X) {
3843                            // radical change means getting out of snap mode
3844                            if (ay > MAX_SLOPE_FOR_DIAG * ax
3845                                    && ay > MIN_BREAK_SNAP_CROSS_DISTANCE) {
3846                                mSnapScrollMode = SNAP_NONE;
3847                            }
3848                            // reverse direction means lock in the snap mode
3849                            if ((ax > MAX_SLOPE_FOR_DIAG * ay) &&
3850                                    ((mSnapPositive &&
3851                                    deltaX < -mMinLockSnapReverseDistance)
3852                                    || (!mSnapPositive &&
3853                                    deltaX > mMinLockSnapReverseDistance))) {
3854                                mSnapScrollMode = SNAP_X_LOCK;
3855                            }
3856                        } else {
3857                            // radical change means getting out of snap mode
3858                            if ((ax > MAX_SLOPE_FOR_DIAG * ay)
3859                                    && ax > MIN_BREAK_SNAP_CROSS_DISTANCE) {
3860                                mSnapScrollMode = SNAP_NONE;
3861                            }
3862                            // reverse direction means lock in the snap mode
3863                            if ((ay > MAX_SLOPE_FOR_DIAG * ax) &&
3864                                    ((mSnapPositive &&
3865                                    deltaY < -mMinLockSnapReverseDistance)
3866                                    || (!mSnapPositive &&
3867                                    deltaY > mMinLockSnapReverseDistance))) {
3868                                mSnapScrollMode = SNAP_Y_LOCK;
3869                            }
3870                        }
3871                    }
3872
3873                    if (mSnapScrollMode == SNAP_X
3874                            || mSnapScrollMode == SNAP_X_LOCK) {
3875                        if (deltaX == 0) {
3876                            // keep the scrollbar on the screen even there is no
3877                            // scroll
3878                            awakenScrollBars(ViewConfiguration
3879                                    .getScrollDefaultDelay(), false);
3880                        } else {
3881                            scrollBy(deltaX, 0);
3882                        }
3883                        mLastTouchX = x;
3884                    } else if (mSnapScrollMode == SNAP_Y
3885                            || mSnapScrollMode == SNAP_Y_LOCK) {
3886                        if (deltaY == 0) {
3887                            // keep the scrollbar on the screen even there is no
3888                            // scroll
3889                            awakenScrollBars(ViewConfiguration
3890                                    .getScrollDefaultDelay(), false);
3891                        } else {
3892                            scrollBy(0, deltaY);
3893                        }
3894                        mLastTouchY = y;
3895                    } else {
3896                        scrollBy(deltaX, deltaY);
3897                        mLastTouchX = x;
3898                        mLastTouchY = y;
3899                    }
3900                    mLastTouchTime = eventTime;
3901                    mUserScroll = true;
3902                }
3903
3904                if (!getSettings().getBuiltInZoomControls()) {
3905                    boolean showPlusMinus = mMinZoomScale < mMaxZoomScale;
3906                    if (mZoomControls != null && showPlusMinus) {
3907                        if (mZoomControls.getVisibility() == View.VISIBLE) {
3908                            mPrivateHandler.removeCallbacks(mZoomControlRunnable);
3909                        } else {
3910                            mZoomControls.show(showPlusMinus, false);
3911                        }
3912                        mPrivateHandler.postDelayed(mZoomControlRunnable,
3913                                ZOOM_CONTROLS_TIMEOUT);
3914                    }
3915                }
3916
3917                if (done) {
3918                    // keep the scrollbar on the screen even there is no scroll
3919                    awakenScrollBars(ViewConfiguration.getScrollDefaultDelay(),
3920                            false);
3921                    // return false to indicate that we can't pan out of the
3922                    // view space
3923                    return false;
3924                }
3925                break;
3926            }
3927            case MotionEvent.ACTION_UP: {
3928                mLastTouchUpTime = eventTime;
3929                switch (mTouchMode) {
3930                    case TOUCH_DOUBLE_TAP_MODE: // double tap
3931                        mPrivateHandler.removeMessages(SWITCH_TO_SHORTPRESS);
3932                        mTouchMode = TOUCH_DONE_MODE;
3933                        doDoubleTap();
3934                        break;
3935                    case TOUCH_SELECT_MODE:
3936                        commitCopy();
3937                        mTouchSelection = false;
3938                        break;
3939                    case TOUCH_INIT_MODE: // tap
3940                    case TOUCH_SHORTPRESS_START_MODE:
3941                    case TOUCH_SHORTPRESS_MODE:
3942                        mPrivateHandler.removeMessages(SWITCH_TO_SHORTPRESS);
3943                        mPrivateHandler.removeMessages(SWITCH_TO_LONGPRESS);
3944                        if ((deltaX * deltaX + deltaY * deltaY) > mTouchSlopSquare) {
3945                            Log.w(LOGTAG, "Miss a drag as we are waiting for" +
3946                                    " WebCore's response for touch down.");
3947                            if (computeHorizontalScrollExtent() < computeHorizontalScrollRange()
3948                                    || computeVerticalScrollExtent() < computeVerticalScrollRange()) {
3949                                // we will not rewrite drag code here, but we
3950                                // will try fling if it applies.
3951                                WebViewCore.pauseUpdate(mWebViewCore);
3952                                // fall through to TOUCH_DRAG_MODE
3953                            } else {
3954                                break;
3955                            }
3956                        } else {
3957                            if (mPreventDrag == PREVENT_DRAG_MAYBE_YES) {
3958                                // if mPreventDrag is not confirmed, treat it as
3959                                // no so that it won't block tap or double tap.
3960                                mPreventDrag = PREVENT_DRAG_NO;
3961                            }
3962                            if (mPreventDrag == PREVENT_DRAG_NO) {
3963                                if (mTouchMode == TOUCH_INIT_MODE) {
3964                                    mPrivateHandler.sendMessageDelayed(
3965                                            mPrivateHandler.obtainMessage(
3966                                            RELEASE_SINGLE_TAP),
3967                                            ViewConfiguration.getDoubleTapTimeout());
3968                                } else {
3969                                    mTouchMode = TOUCH_DONE_MODE;
3970                                    doShortPress();
3971                                }
3972                            }
3973                            break;
3974                        }
3975                    case TOUCH_DRAG_MODE:
3976                        // redraw in high-quality, as we're done dragging
3977                        invalidate();
3978                        // if the user waits a while w/o moving before the
3979                        // up, we don't want to do a fling
3980                        if (eventTime - mLastTouchTime <= MIN_FLING_TIME) {
3981                            mVelocityTracker.addMovement(ev);
3982                            doFling();
3983                            break;
3984                        }
3985                        mLastVelocity = 0;
3986                        WebViewCore.resumeUpdate(mWebViewCore);
3987                        break;
3988                    case TOUCH_DRAG_START_MODE:
3989                    case TOUCH_DONE_MODE:
3990                        // do nothing
3991                        break;
3992                }
3993                // we also use mVelocityTracker == null to tell us that we are
3994                // not "moving around", so we can take the slower/prettier
3995                // mode in the drawing code
3996                if (mVelocityTracker != null) {
3997                    mVelocityTracker.recycle();
3998                    mVelocityTracker = null;
3999                }
4000                break;
4001            }
4002            case MotionEvent.ACTION_CANCEL: {
4003                // we also use mVelocityTracker == null to tell us that we are
4004                // not "moving around", so we can take the slower/prettier
4005                // mode in the drawing code
4006                if (mVelocityTracker != null) {
4007                    mVelocityTracker.recycle();
4008                    mVelocityTracker = null;
4009                }
4010                if (mTouchMode == TOUCH_DRAG_MODE) {
4011                    WebViewCore.resumeUpdate(mWebViewCore);
4012                }
4013                mPrivateHandler.removeMessages(SWITCH_TO_SHORTPRESS);
4014                mPrivateHandler.removeMessages(SWITCH_TO_LONGPRESS);
4015                mTouchMode = TOUCH_DONE_MODE;
4016                nativeHideCursor();
4017                break;
4018            }
4019        }
4020        return true;
4021    }
4022
4023    private long mTrackballFirstTime = 0;
4024    private long mTrackballLastTime = 0;
4025    private float mTrackballRemainsX = 0.0f;
4026    private float mTrackballRemainsY = 0.0f;
4027    private int mTrackballXMove = 0;
4028    private int mTrackballYMove = 0;
4029    private boolean mExtendSelection = false;
4030    private boolean mTouchSelection = false;
4031    private static final int TRACKBALL_KEY_TIMEOUT = 1000;
4032    private static final int TRACKBALL_TIMEOUT = 200;
4033    private static final int TRACKBALL_WAIT = 100;
4034    private static final int TRACKBALL_SCALE = 400;
4035    private static final int TRACKBALL_SCROLL_COUNT = 5;
4036    private static final int TRACKBALL_MOVE_COUNT = 10;
4037    private static final int TRACKBALL_MULTIPLIER = 3;
4038    private static final int SELECT_CURSOR_OFFSET = 16;
4039    private int mSelectX = 0;
4040    private int mSelectY = 0;
4041    private boolean mShiftIsPressed = false;
4042    private boolean mTrackballDown = false;
4043    private long mTrackballUpTime = 0;
4044    private long mLastCursorTime = 0;
4045    private Rect mLastCursorBounds;
4046
4047    // Set by default; BrowserActivity clears to interpret trackball data
4048    // directly for movement. Currently, the framework only passes
4049    // arrow key events, not trackball events, from one child to the next
4050    private boolean mMapTrackballToArrowKeys = true;
4051
4052    public void setMapTrackballToArrowKeys(boolean setMap) {
4053        mMapTrackballToArrowKeys = setMap;
4054    }
4055
4056    void resetTrackballTime() {
4057        mTrackballLastTime = 0;
4058    }
4059
4060    @Override
4061    public boolean onTrackballEvent(MotionEvent ev) {
4062        long time = ev.getEventTime();
4063        if ((ev.getMetaState() & KeyEvent.META_ALT_ON) != 0) {
4064            if (ev.getY() > 0) pageDown(true);
4065            if (ev.getY() < 0) pageUp(true);
4066            return true;
4067        }
4068        if (ev.getAction() == MotionEvent.ACTION_DOWN) {
4069            if (mShiftIsPressed) {
4070                return true; // discard press if copy in progress
4071            }
4072            mTrackballDown = true;
4073            if (mNativeClass == 0) {
4074                return false;
4075            }
4076            nativeRecordButtons(hasFocus() && hasWindowFocus(), true, true);
4077            if (time - mLastCursorTime <= TRACKBALL_TIMEOUT
4078                    && !mLastCursorBounds.equals(nativeGetCursorRingBounds())) {
4079                nativeSelectBestAt(mLastCursorBounds);
4080            }
4081            if (DebugFlags.WEB_VIEW) {
4082                Log.v(LOGTAG, "onTrackballEvent down ev=" + ev
4083                        + " time=" + time
4084                        + " mLastCursorTime=" + mLastCursorTime);
4085            }
4086            if (isInTouchMode()) requestFocusFromTouch();
4087            return false; // let common code in onKeyDown at it
4088        }
4089        if (ev.getAction() == MotionEvent.ACTION_UP) {
4090            // LONG_PRESS_CENTER is set in common onKeyDown
4091            mPrivateHandler.removeMessages(LONG_PRESS_CENTER);
4092            mTrackballDown = false;
4093            mTrackballUpTime = time;
4094            if (mShiftIsPressed) {
4095                if (mExtendSelection) {
4096                    commitCopy();
4097                } else {
4098                    mExtendSelection = true;
4099                }
4100                return true; // discard press if copy in progress
4101            }
4102            if (DebugFlags.WEB_VIEW) {
4103                Log.v(LOGTAG, "onTrackballEvent up ev=" + ev
4104                        + " time=" + time
4105                );
4106            }
4107            return false; // let common code in onKeyUp at it
4108        }
4109        if (mMapTrackballToArrowKeys && mShiftIsPressed == false) {
4110            if (DebugFlags.WEB_VIEW) Log.v(LOGTAG, "onTrackballEvent gmail quit");
4111            return false;
4112        }
4113        if (mTrackballDown) {
4114            if (DebugFlags.WEB_VIEW) Log.v(LOGTAG, "onTrackballEvent down quit");
4115            return true; // discard move if trackball is down
4116        }
4117        if (time - mTrackballUpTime < TRACKBALL_TIMEOUT) {
4118            if (DebugFlags.WEB_VIEW) Log.v(LOGTAG, "onTrackballEvent up timeout quit");
4119            return true;
4120        }
4121        // TODO: alternatively we can do panning as touch does
4122        switchOutDrawHistory();
4123        if (time - mTrackballLastTime > TRACKBALL_TIMEOUT) {
4124            if (DebugFlags.WEB_VIEW) {
4125                Log.v(LOGTAG, "onTrackballEvent time="
4126                        + time + " last=" + mTrackballLastTime);
4127            }
4128            mTrackballFirstTime = time;
4129            mTrackballXMove = mTrackballYMove = 0;
4130        }
4131        mTrackballLastTime = time;
4132        if (DebugFlags.WEB_VIEW) {
4133            Log.v(LOGTAG, "onTrackballEvent ev=" + ev + " time=" + time);
4134        }
4135        mTrackballRemainsX += ev.getX();
4136        mTrackballRemainsY += ev.getY();
4137        doTrackball(time);
4138        return true;
4139    }
4140
4141    void moveSelection(float xRate, float yRate) {
4142        if (mNativeClass == 0)
4143            return;
4144        int width = getViewWidth();
4145        int height = getViewHeight();
4146        mSelectX += scaleTrackballX(xRate, width);
4147        mSelectY += scaleTrackballY(yRate, height);
4148        int maxX = width + mScrollX;
4149        int maxY = height + mScrollY;
4150        mSelectX = Math.min(maxX, Math.max(mScrollX - SELECT_CURSOR_OFFSET
4151                , mSelectX));
4152        mSelectY = Math.min(maxY, Math.max(mScrollY - SELECT_CURSOR_OFFSET
4153                , mSelectY));
4154        if (DebugFlags.WEB_VIEW) {
4155            Log.v(LOGTAG, "moveSelection"
4156                    + " mSelectX=" + mSelectX
4157                    + " mSelectY=" + mSelectY
4158                    + " mScrollX=" + mScrollX
4159                    + " mScrollY=" + mScrollY
4160                    + " xRate=" + xRate
4161                    + " yRate=" + yRate
4162                    );
4163        }
4164        nativeMoveSelection(viewToContentX(mSelectX),
4165                viewToContentY(mSelectY), mExtendSelection);
4166        int scrollX = mSelectX < mScrollX ? -SELECT_CURSOR_OFFSET
4167                : mSelectX > maxX - SELECT_CURSOR_OFFSET ? SELECT_CURSOR_OFFSET
4168                : 0;
4169        int scrollY = mSelectY < mScrollY ? -SELECT_CURSOR_OFFSET
4170                : mSelectY > maxY - SELECT_CURSOR_OFFSET ? SELECT_CURSOR_OFFSET
4171                : 0;
4172        pinScrollBy(scrollX, scrollY, true, 0);
4173        Rect select = new Rect(mSelectX, mSelectY, mSelectX + 1, mSelectY + 1);
4174        requestRectangleOnScreen(select);
4175        invalidate();
4176   }
4177
4178    private int scaleTrackballX(float xRate, int width) {
4179        int xMove = (int) (xRate / TRACKBALL_SCALE * width);
4180        int nextXMove = xMove;
4181        if (xMove > 0) {
4182            if (xMove > mTrackballXMove) {
4183                xMove -= mTrackballXMove;
4184            }
4185        } else if (xMove < mTrackballXMove) {
4186            xMove -= mTrackballXMove;
4187        }
4188        mTrackballXMove = nextXMove;
4189        return xMove;
4190    }
4191
4192    private int scaleTrackballY(float yRate, int height) {
4193        int yMove = (int) (yRate / TRACKBALL_SCALE * height);
4194        int nextYMove = yMove;
4195        if (yMove > 0) {
4196            if (yMove > mTrackballYMove) {
4197                yMove -= mTrackballYMove;
4198            }
4199        } else if (yMove < mTrackballYMove) {
4200            yMove -= mTrackballYMove;
4201        }
4202        mTrackballYMove = nextYMove;
4203        return yMove;
4204    }
4205
4206    private int keyCodeToSoundsEffect(int keyCode) {
4207        switch(keyCode) {
4208            case KeyEvent.KEYCODE_DPAD_UP:
4209                return SoundEffectConstants.NAVIGATION_UP;
4210            case KeyEvent.KEYCODE_DPAD_RIGHT:
4211                return SoundEffectConstants.NAVIGATION_RIGHT;
4212            case KeyEvent.KEYCODE_DPAD_DOWN:
4213                return SoundEffectConstants.NAVIGATION_DOWN;
4214            case KeyEvent.KEYCODE_DPAD_LEFT:
4215                return SoundEffectConstants.NAVIGATION_LEFT;
4216        }
4217        throw new IllegalArgumentException("keyCode must be one of " +
4218                "{KEYCODE_DPAD_UP, KEYCODE_DPAD_RIGHT, KEYCODE_DPAD_DOWN, " +
4219                "KEYCODE_DPAD_LEFT}.");
4220    }
4221
4222    private void doTrackball(long time) {
4223        int elapsed = (int) (mTrackballLastTime - mTrackballFirstTime);
4224        if (elapsed == 0) {
4225            elapsed = TRACKBALL_TIMEOUT;
4226        }
4227        float xRate = mTrackballRemainsX * 1000 / elapsed;
4228        float yRate = mTrackballRemainsY * 1000 / elapsed;
4229        if (mShiftIsPressed) {
4230            moveSelection(xRate, yRate);
4231            mTrackballRemainsX = mTrackballRemainsY = 0;
4232            return;
4233        }
4234        float ax = Math.abs(xRate);
4235        float ay = Math.abs(yRate);
4236        float maxA = Math.max(ax, ay);
4237        if (DebugFlags.WEB_VIEW) {
4238            Log.v(LOGTAG, "doTrackball elapsed=" + elapsed
4239                    + " xRate=" + xRate
4240                    + " yRate=" + yRate
4241                    + " mTrackballRemainsX=" + mTrackballRemainsX
4242                    + " mTrackballRemainsY=" + mTrackballRemainsY);
4243        }
4244        int width = mContentWidth - getViewWidth();
4245        int height = mContentHeight - getViewHeight();
4246        if (width < 0) width = 0;
4247        if (height < 0) height = 0;
4248        ax = Math.abs(mTrackballRemainsX * TRACKBALL_MULTIPLIER);
4249        ay = Math.abs(mTrackballRemainsY * TRACKBALL_MULTIPLIER);
4250        maxA = Math.max(ax, ay);
4251        int count = Math.max(0, (int) maxA);
4252        int oldScrollX = mScrollX;
4253        int oldScrollY = mScrollY;
4254        if (count > 0) {
4255            int selectKeyCode = ax < ay ? mTrackballRemainsY < 0 ?
4256                    KeyEvent.KEYCODE_DPAD_UP : KeyEvent.KEYCODE_DPAD_DOWN :
4257                    mTrackballRemainsX < 0 ? KeyEvent.KEYCODE_DPAD_LEFT :
4258                    KeyEvent.KEYCODE_DPAD_RIGHT;
4259            count = Math.min(count, TRACKBALL_MOVE_COUNT);
4260            if (DebugFlags.WEB_VIEW) {
4261                Log.v(LOGTAG, "doTrackball keyCode=" + selectKeyCode
4262                        + " count=" + count
4263                        + " mTrackballRemainsX=" + mTrackballRemainsX
4264                        + " mTrackballRemainsY=" + mTrackballRemainsY);
4265            }
4266            if (navHandledKey(selectKeyCode, count, false, time, false)) {
4267                playSoundEffect(keyCodeToSoundsEffect(selectKeyCode));
4268            }
4269            mTrackballRemainsX = mTrackballRemainsY = 0;
4270        }
4271        if (count >= TRACKBALL_SCROLL_COUNT) {
4272            int xMove = scaleTrackballX(xRate, width);
4273            int yMove = scaleTrackballY(yRate, height);
4274            if (DebugFlags.WEB_VIEW) {
4275                Log.v(LOGTAG, "doTrackball pinScrollBy"
4276                        + " count=" + count
4277                        + " xMove=" + xMove + " yMove=" + yMove
4278                        + " mScrollX-oldScrollX=" + (mScrollX-oldScrollX)
4279                        + " mScrollY-oldScrollY=" + (mScrollY-oldScrollY)
4280                        );
4281            }
4282            if (Math.abs(mScrollX - oldScrollX) > Math.abs(xMove)) {
4283                xMove = 0;
4284            }
4285            if (Math.abs(mScrollY - oldScrollY) > Math.abs(yMove)) {
4286                yMove = 0;
4287            }
4288            if (xMove != 0 || yMove != 0) {
4289                pinScrollBy(xMove, yMove, true, 0);
4290            }
4291            mUserScroll = true;
4292        }
4293    }
4294
4295    private int computeMaxScrollY() {
4296        int maxContentH = computeVerticalScrollRange() + getTitleHeight();
4297        return Math.max(maxContentH - getHeight(), getTitleHeight());
4298    }
4299
4300    public void flingScroll(int vx, int vy) {
4301        int maxX = Math.max(computeHorizontalScrollRange() - getViewWidth(), 0);
4302        int maxY = computeMaxScrollY();
4303
4304        mScroller.fling(mScrollX, mScrollY, vx, vy, 0, maxX, 0, maxY);
4305        invalidate();
4306    }
4307
4308    private void doFling() {
4309        if (mVelocityTracker == null) {
4310            return;
4311        }
4312        int maxX = Math.max(computeHorizontalScrollRange() - getViewWidth(), 0);
4313        int maxY = computeMaxScrollY();
4314
4315        mVelocityTracker.computeCurrentVelocity(1000, mMaximumFling);
4316        int vx = (int) mVelocityTracker.getXVelocity();
4317        int vy = (int) mVelocityTracker.getYVelocity();
4318
4319        if (mSnapScrollMode != SNAP_NONE) {
4320            if (mSnapScrollMode == SNAP_X || mSnapScrollMode == SNAP_X_LOCK) {
4321                vy = 0;
4322            } else {
4323                vx = 0;
4324            }
4325        }
4326
4327        if (true /* EMG release: make our fling more like Maps' */) {
4328            // maps cuts their velocity in half
4329            vx = vx * 3 / 4;
4330            vy = vy * 3 / 4;
4331        }
4332        if ((maxX == 0 && vy == 0) || (maxY == 0 && vx == 0)) {
4333            WebViewCore.resumeUpdate(mWebViewCore);
4334            return;
4335        }
4336        float currentVelocity = mScroller.getCurrVelocity();
4337        if (mLastVelocity > 0 && currentVelocity > 0) {
4338            float deltaR = (float) (Math.abs(Math.atan2(mLastVelY, mLastVelX)
4339                    - Math.atan2(vy, vx)));
4340            final float circle = (float) (Math.PI) * 2.0f;
4341            if (deltaR > circle * 0.9f || deltaR < circle * 0.1f) {
4342                vx += currentVelocity * mLastVelX / mLastVelocity;
4343                vy += currentVelocity * mLastVelY / mLastVelocity;
4344                if (DebugFlags.WEB_VIEW) {
4345                    Log.v(LOGTAG, "doFling vx= " + vx + " vy=" + vy);
4346                }
4347            } else if (DebugFlags.WEB_VIEW) {
4348                Log.v(LOGTAG, "doFling missed " + deltaR / circle);
4349            }
4350        } else if (DebugFlags.WEB_VIEW) {
4351            Log.v(LOGTAG, "doFling start last=" + mLastVelocity
4352                    + " current=" + currentVelocity
4353                    + " vx=" + vx + " vy=" + vy
4354                    + " maxX=" + maxX + " maxY=" + maxY
4355                    + " mScrollX=" + mScrollX + " mScrollY=" + mScrollY);
4356        }
4357        mLastVelX = vx;
4358        mLastVelY = vy;
4359        mLastVelocity = (float) Math.hypot(vx, vy);
4360
4361        mScroller.fling(mScrollX, mScrollY, -vx, -vy, 0, maxX, 0, maxY);
4362        // TODO: duration is calculated based on velocity, if the range is
4363        // small, the animation will stop before duration is up. We may
4364        // want to calculate how long the animation is going to run to precisely
4365        // resume the webcore update.
4366        final int time = mScroller.getDuration();
4367        mPrivateHandler.sendEmptyMessageDelayed(RESUME_WEBCORE_UPDATE, time);
4368        awakenScrollBars(time);
4369        invalidate();
4370    }
4371
4372    private boolean zoomWithPreview(float scale) {
4373        float oldScale = mActualScale;
4374        mInitialScrollX = mScrollX;
4375        mInitialScrollY = mScrollY;
4376
4377        // snap to DEFAULT_SCALE if it is close
4378        if (scale > (mDefaultScale - 0.05) && scale < (mDefaultScale + 0.05)) {
4379            scale = mDefaultScale;
4380        }
4381
4382        setNewZoomScale(scale, false);
4383
4384        if (oldScale != mActualScale) {
4385            // use mZoomPickerScale to see zoom preview first
4386            mZoomStart = SystemClock.uptimeMillis();
4387            mInvInitialZoomScale = 1.0f / oldScale;
4388            mInvFinalZoomScale = 1.0f / mActualScale;
4389            mZoomScale = mActualScale;
4390            if (!mInZoomOverview) {
4391                mLastScale = scale;
4392            }
4393            invalidate();
4394            return true;
4395        } else {
4396            return false;
4397        }
4398    }
4399
4400    /**
4401     * Returns a view containing zoom controls i.e. +/- buttons. The caller is
4402     * in charge of installing this view to the view hierarchy. This view will
4403     * become visible when the user starts scrolling via touch and fade away if
4404     * the user does not interact with it.
4405     * <p/>
4406     * API version 3 introduces a built-in zoom mechanism that is shown
4407     * automatically by the MapView. This is the preferred approach for
4408     * showing the zoom UI.
4409     *
4410     * @deprecated The built-in zoom mechanism is preferred, see
4411     *             {@link WebSettings#setBuiltInZoomControls(boolean)}.
4412     */
4413    @Deprecated
4414    public View getZoomControls() {
4415        if (!getSettings().supportZoom()) {
4416            Log.w(LOGTAG, "This WebView doesn't support zoom.");
4417            return null;
4418        }
4419        if (mZoomControls == null) {
4420            mZoomControls = createZoomControls();
4421
4422            /*
4423             * need to be set to VISIBLE first so that getMeasuredHeight() in
4424             * {@link #onSizeChanged()} can return the measured value for proper
4425             * layout.
4426             */
4427            mZoomControls.setVisibility(View.VISIBLE);
4428            mZoomControlRunnable = new Runnable() {
4429                public void run() {
4430
4431                    /* Don't dismiss the controls if the user has
4432                     * focus on them. Wait and check again later.
4433                     */
4434                    if (!mZoomControls.hasFocus()) {
4435                        mZoomControls.hide();
4436                    } else {
4437                        mPrivateHandler.removeCallbacks(mZoomControlRunnable);
4438                        mPrivateHandler.postDelayed(mZoomControlRunnable,
4439                                ZOOM_CONTROLS_TIMEOUT);
4440                    }
4441                }
4442            };
4443        }
4444        return mZoomControls;
4445    }
4446
4447    private ExtendedZoomControls createZoomControls() {
4448        ExtendedZoomControls zoomControls = new ExtendedZoomControls(mContext
4449            , null);
4450        zoomControls.setOnZoomInClickListener(new OnClickListener() {
4451            public void onClick(View v) {
4452                // reset time out
4453                mPrivateHandler.removeCallbacks(mZoomControlRunnable);
4454                mPrivateHandler.postDelayed(mZoomControlRunnable,
4455                        ZOOM_CONTROLS_TIMEOUT);
4456                zoomIn();
4457            }
4458        });
4459        zoomControls.setOnZoomOutClickListener(new OnClickListener() {
4460            public void onClick(View v) {
4461                // reset time out
4462                mPrivateHandler.removeCallbacks(mZoomControlRunnable);
4463                mPrivateHandler.postDelayed(mZoomControlRunnable,
4464                        ZOOM_CONTROLS_TIMEOUT);
4465                zoomOut();
4466            }
4467        });
4468        return zoomControls;
4469    }
4470
4471    /**
4472     * Gets the {@link ZoomButtonsController} which can be used to add
4473     * additional buttons to the zoom controls window.
4474     *
4475     * @return The instance of {@link ZoomButtonsController} used by this class,
4476     *         or null if it is unavailable.
4477     * @hide
4478     */
4479    public ZoomButtonsController getZoomButtonsController() {
4480        return mZoomButtonsController;
4481    }
4482
4483    /**
4484     * Perform zoom in in the webview
4485     * @return TRUE if zoom in succeeds. FALSE if no zoom changes.
4486     */
4487    public boolean zoomIn() {
4488        // TODO: alternatively we can disallow this during draw history mode
4489        switchOutDrawHistory();
4490        // Center zooming to the center of the screen.
4491        if (mInZoomOverview) {
4492            // if in overview mode, bring it back to normal mode
4493            mLastTouchX = getViewWidth() * .5f;
4494            mLastTouchY = getViewHeight() * .5f;
4495            doDoubleTap();
4496            return true;
4497        } else {
4498            mZoomCenterX = getViewWidth() * .5f;
4499            mZoomCenterY = getViewHeight() * .5f;
4500            return zoomWithPreview(mActualScale * 1.25f);
4501        }
4502    }
4503
4504    /**
4505     * Perform zoom out in the webview
4506     * @return TRUE if zoom out succeeds. FALSE if no zoom changes.
4507     */
4508    public boolean zoomOut() {
4509        // TODO: alternatively we can disallow this during draw history mode
4510        switchOutDrawHistory();
4511        float scale = mActualScale * 0.8f;
4512        if (scale < (mMinZoomScale + 0.1f)
4513                && mWebViewCore.getSettings().getUseWideViewPort()) {
4514            // when zoom out to min scale, switch to overview mode
4515            doDoubleTap();
4516            return true;
4517        } else {
4518            // Center zooming to the center of the screen.
4519            mZoomCenterX = getViewWidth() * .5f;
4520            mZoomCenterY = getViewHeight() * .5f;
4521            return zoomWithPreview(scale);
4522        }
4523    }
4524
4525    private void updateSelection() {
4526        if (mNativeClass == 0) {
4527            return;
4528        }
4529        // mLastTouchX and mLastTouchY are the point in the current viewport
4530        int contentX = viewToContentX((int) mLastTouchX + mScrollX);
4531        int contentY = viewToContentY((int) mLastTouchY + mScrollY);
4532        Rect rect = new Rect(contentX - mNavSlop, contentY - mNavSlop,
4533                contentX + mNavSlop, contentY + mNavSlop);
4534        nativeSelectBestAt(rect);
4535    }
4536
4537    /**
4538     * Scroll the focused text field/area to match the WebTextView
4539     * @param xPercent New x position of the WebTextView from 0 to 1.
4540     * @param y New y position of the WebTextView in view coordinates
4541     */
4542    /*package*/ void scrollFocusedTextInput(float xPercent, int y) {
4543        if (!inEditingMode() || mWebViewCore == null) {
4544            return;
4545        }
4546        mWebViewCore.sendMessage(EventHub.SCROLL_TEXT_INPUT,
4547                // Since this position is relative to the top of the text input
4548                // field, we do not need to take the title bar's height into
4549                // consideration.
4550                viewToContentDimension(y),
4551                new Float(xPercent));
4552    }
4553
4554    /**
4555     * Set our starting point and time for a drag from the WebTextView.
4556     */
4557    /*package*/ void initiateTextFieldDrag(float x, float y, long eventTime) {
4558        if (!inEditingMode()) {
4559            return;
4560        }
4561        mLastTouchX = x + (float) (mWebTextView.getLeft() - mScrollX);
4562        mLastTouchY = y + (float) (mWebTextView.getTop() - mScrollY);
4563        mLastTouchTime = eventTime;
4564        if (!mScroller.isFinished()) {
4565            abortAnimation();
4566            mPrivateHandler.removeMessages(RESUME_WEBCORE_UPDATE);
4567        }
4568        mSnapScrollMode = SNAP_NONE;
4569        mVelocityTracker = VelocityTracker.obtain();
4570        mTouchMode = TOUCH_DRAG_START_MODE;
4571    }
4572
4573    /**
4574     * Given a motion event from the WebTextView, set its location to our
4575     * coordinates, and handle the event.
4576     */
4577    /*package*/ boolean textFieldDrag(MotionEvent event) {
4578        if (!inEditingMode()) {
4579            return false;
4580        }
4581        mDragFromTextInput = true;
4582        event.offsetLocation((float) (mWebTextView.getLeft() - mScrollX),
4583                (float) (mWebTextView.getTop() - mScrollY));
4584        boolean result = onTouchEvent(event);
4585        mDragFromTextInput = false;
4586        return result;
4587    }
4588
4589    /**
4590     * Do a touch up from a WebTextView.  This will be handled by webkit to
4591     * change the selection.
4592     * @param event MotionEvent in the WebTextView's coordinates.
4593     */
4594    /*package*/ void touchUpOnTextField(MotionEvent event) {
4595        if (!inEditingMode()) {
4596            return;
4597        }
4598        int x = viewToContentX((int) event.getX() + mWebTextView.getLeft());
4599        int y = viewToContentY((int) event.getY() + mWebTextView.getTop());
4600        // In case the soft keyboard has been dismissed, bring it back up.
4601        InputMethodManager.getInstance(getContext()).showSoftInput(mWebTextView,
4602                0);
4603        if (nativeFocusNodePointer() != nativeCursorNodePointer()) {
4604            nativeMotionUp(x, y, mNavSlop);
4605        }
4606        nativeTextInputMotionUp(x, y);
4607    }
4608
4609    /*package*/ void shortPressOnTextField() {
4610        if (inEditingMode()) {
4611            View v = mWebTextView;
4612            int x = viewToContentX((v.getLeft() + v.getRight()) >> 1);
4613            int y = viewToContentY((v.getTop() + v.getBottom()) >> 1);
4614            nativeTextInputMotionUp(x, y);
4615        }
4616    }
4617
4618    private void doShortPress() {
4619        if (mNativeClass == 0) {
4620            return;
4621        }
4622        switchOutDrawHistory();
4623        // mLastTouchX and mLastTouchY are the point in the current viewport
4624        int contentX = viewToContentX((int) mLastTouchX + mScrollX);
4625        int contentY = viewToContentY((int) mLastTouchY + mScrollY);
4626        if (nativeMotionUp(contentX, contentY, mNavSlop)) {
4627            if (mLogEvent) {
4628                Checkin.updateStats(mContext.getContentResolver(),
4629                        Checkin.Stats.Tag.BROWSER_SNAP_CENTER, 1, 0.0);
4630            }
4631        }
4632        if (nativeHasCursorNode() && !nativeCursorIsTextInput()) {
4633            playSoundEffect(SoundEffectConstants.CLICK);
4634        }
4635    }
4636
4637    private void doDoubleTap() {
4638        if (mWebViewCore.getSettings().getUseWideViewPort() == false) {
4639            return;
4640        }
4641        mZoomCenterX = mLastTouchX;
4642        mZoomCenterY = mLastTouchY;
4643        mInZoomOverview = !mInZoomOverview;
4644        // remove the zoom control after double tap
4645        WebSettings settings = getSettings();
4646        if (settings.getBuiltInZoomControls()) {
4647            if (mZoomButtonsController.isVisible()) {
4648                mZoomButtonsController.setVisible(false);
4649            }
4650        } else {
4651            if (mZoomControlRunnable != null) {
4652                mPrivateHandler.removeCallbacks(mZoomControlRunnable);
4653            }
4654            if (mZoomControls != null) {
4655                mZoomControls.hide();
4656            }
4657        }
4658        settings.setDoubleTapToastCount(0);
4659        if (mInZoomOverview) {
4660            // Force the titlebar fully reveal in overview mode
4661            if (mScrollY < getTitleHeight()) mScrollY = 0;
4662            zoomWithPreview((float) getViewWidth() / mZoomOverviewWidth);
4663        } else {
4664            // mLastTouchX and mLastTouchY are the point in the current viewport
4665            int contentX = viewToContentX((int) mLastTouchX + mScrollX);
4666            int contentY = viewToContentY((int) mLastTouchY + mScrollY);
4667            int left = nativeGetBlockLeftEdge(contentX, contentY, mActualScale);
4668            if (left != NO_LEFTEDGE) {
4669                // add a 5pt padding to the left edge. Re-calculate the zoom
4670                // center so that the new scroll x will be on the left edge.
4671                mZoomCenterX = left < 5 ? 0 : (left - 5) * mLastScale
4672                        * mActualScale / (mLastScale - mActualScale);
4673            }
4674            zoomWithPreview(mLastScale);
4675        }
4676    }
4677
4678    // Called by JNI to handle a touch on a node representing an email address,
4679    // address, or phone number
4680    private void overrideLoading(String url) {
4681        mCallbackProxy.uiOverrideUrlLoading(url);
4682    }
4683
4684    // called by JNI
4685    private void sendPluginState(int state) {
4686        WebViewCore.PluginStateData psd = new WebViewCore.PluginStateData();
4687        psd.mFrame = nativeCursorFramePointer();
4688        psd.mNode = nativeCursorNodePointer();
4689        psd.mState = state;
4690        mWebViewCore.sendMessage(EventHub.PLUGIN_STATE, psd);
4691    }
4692
4693    @Override
4694    public boolean requestFocus(int direction, Rect previouslyFocusedRect) {
4695        boolean result = false;
4696        if (inEditingMode()) {
4697            result = mWebTextView.requestFocus(direction,
4698                    previouslyFocusedRect);
4699        } else {
4700            result = super.requestFocus(direction, previouslyFocusedRect);
4701            if (mWebViewCore.getSettings().getNeedInitialFocus()) {
4702                // For cases such as GMail, where we gain focus from a direction,
4703                // we want to move to the first available link.
4704                // FIXME: If there are no visible links, we may not want to
4705                int fakeKeyDirection = 0;
4706                switch(direction) {
4707                    case View.FOCUS_UP:
4708                        fakeKeyDirection = KeyEvent.KEYCODE_DPAD_UP;
4709                        break;
4710                    case View.FOCUS_DOWN:
4711                        fakeKeyDirection = KeyEvent.KEYCODE_DPAD_DOWN;
4712                        break;
4713                    case View.FOCUS_LEFT:
4714                        fakeKeyDirection = KeyEvent.KEYCODE_DPAD_LEFT;
4715                        break;
4716                    case View.FOCUS_RIGHT:
4717                        fakeKeyDirection = KeyEvent.KEYCODE_DPAD_RIGHT;
4718                        break;
4719                    default:
4720                        return result;
4721                }
4722                if (mNativeClass != 0 && !nativeHasCursorNode()) {
4723                    navHandledKey(fakeKeyDirection, 1, true, 0, true);
4724                }
4725            }
4726        }
4727        return result;
4728    }
4729
4730    @Override
4731    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
4732        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
4733
4734        int heightMode = MeasureSpec.getMode(heightMeasureSpec);
4735        int heightSize = MeasureSpec.getSize(heightMeasureSpec);
4736        int widthMode = MeasureSpec.getMode(widthMeasureSpec);
4737        int widthSize = MeasureSpec.getSize(widthMeasureSpec);
4738
4739        int measuredHeight = heightSize;
4740        int measuredWidth = widthSize;
4741
4742        // Grab the content size from WebViewCore.
4743        int contentHeight = contentToViewDimension(mContentHeight);
4744        int contentWidth = contentToViewDimension(mContentWidth);
4745
4746//        Log.d(LOGTAG, "------- measure " + heightMode);
4747
4748        if (heightMode != MeasureSpec.EXACTLY) {
4749            mHeightCanMeasure = true;
4750            measuredHeight = contentHeight;
4751            if (heightMode == MeasureSpec.AT_MOST) {
4752                // If we are larger than the AT_MOST height, then our height can
4753                // no longer be measured and we should scroll internally.
4754                if (measuredHeight > heightSize) {
4755                    measuredHeight = heightSize;
4756                    mHeightCanMeasure = false;
4757                }
4758            }
4759        } else {
4760            mHeightCanMeasure = false;
4761        }
4762        if (mNativeClass != 0) {
4763            nativeSetHeightCanMeasure(mHeightCanMeasure);
4764        }
4765        // For the width, always use the given size unless unspecified.
4766        if (widthMode == MeasureSpec.UNSPECIFIED) {
4767            mWidthCanMeasure = true;
4768            measuredWidth = contentWidth;
4769        } else {
4770            mWidthCanMeasure = false;
4771        }
4772
4773        synchronized (this) {
4774            setMeasuredDimension(measuredWidth, measuredHeight);
4775        }
4776    }
4777
4778    @Override
4779    public boolean requestChildRectangleOnScreen(View child,
4780                                                 Rect rect,
4781                                                 boolean immediate) {
4782        rect.offset(child.getLeft() - child.getScrollX(),
4783                child.getTop() - child.getScrollY());
4784
4785        int height = getViewHeightWithTitle();
4786        int screenTop = mScrollY;
4787        int screenBottom = screenTop + height;
4788
4789        int scrollYDelta = 0;
4790
4791        if (rect.bottom > screenBottom) {
4792            int oneThirdOfScreenHeight = height / 3;
4793            if (rect.height() > 2 * oneThirdOfScreenHeight) {
4794                // If the rectangle is too tall to fit in the bottom two thirds
4795                // of the screen, place it at the top.
4796                scrollYDelta = rect.top - screenTop;
4797            } else {
4798                // If the rectangle will still fit on screen, we want its
4799                // top to be in the top third of the screen.
4800                scrollYDelta = rect.top - (screenTop + oneThirdOfScreenHeight);
4801            }
4802        } else if (rect.top < screenTop) {
4803            scrollYDelta = rect.top - screenTop;
4804        }
4805
4806        int width = getWidth() - getVerticalScrollbarWidth();
4807        int screenLeft = mScrollX;
4808        int screenRight = screenLeft + width;
4809
4810        int scrollXDelta = 0;
4811
4812        if (rect.right > screenRight && rect.left > screenLeft) {
4813            if (rect.width() > width) {
4814                scrollXDelta += (rect.left - screenLeft);
4815            } else {
4816                scrollXDelta += (rect.right - screenRight);
4817            }
4818        } else if (rect.left < screenLeft) {
4819            scrollXDelta -= (screenLeft - rect.left);
4820        }
4821
4822        if ((scrollYDelta | scrollXDelta) != 0) {
4823            return pinScrollBy(scrollXDelta, scrollYDelta, !immediate, 0);
4824        }
4825
4826        return false;
4827    }
4828
4829    /* package */ void replaceTextfieldText(int oldStart, int oldEnd,
4830            String replace, int newStart, int newEnd) {
4831        WebViewCore.ReplaceTextData arg = new WebViewCore.ReplaceTextData();
4832        arg.mReplace = replace;
4833        arg.mNewStart = newStart;
4834        arg.mNewEnd = newEnd;
4835        mTextGeneration++;
4836        arg.mTextGeneration = mTextGeneration;
4837        mWebViewCore.sendMessage(EventHub.REPLACE_TEXT, oldStart, oldEnd, arg);
4838    }
4839
4840    /* package */ void passToJavaScript(String currentText, KeyEvent event) {
4841        if (nativeCursorWantsKeyEvents() && !nativeCursorMatchesFocus()) {
4842            mWebViewCore.sendMessage(EventHub.CLICK);
4843            if (mWebTextView.mOkayForFocusNotToMatch) {
4844                int select = nativeFocusCandidateIsTextField() ?
4845                        nativeFocusCandidateMaxLength() : 0;
4846                setSelection(select, select);
4847            }
4848        }
4849        WebViewCore.JSKeyData arg = new WebViewCore.JSKeyData();
4850        arg.mEvent = event;
4851        arg.mCurrentText = currentText;
4852        // Increase our text generation number, and pass it to webcore thread
4853        mTextGeneration++;
4854        mWebViewCore.sendMessage(EventHub.PASS_TO_JS, mTextGeneration, 0, arg);
4855        // WebKit's document state is not saved until about to leave the page.
4856        // To make sure the host application, like Browser, has the up to date
4857        // document state when it goes to background, we force to save the
4858        // document state.
4859        mWebViewCore.removeMessages(EventHub.SAVE_DOCUMENT_STATE);
4860        mWebViewCore.sendMessageDelayed(EventHub.SAVE_DOCUMENT_STATE,
4861                cursorData(), 1000);
4862    }
4863
4864    /* package */ WebViewCore getWebViewCore() {
4865        return mWebViewCore;
4866    }
4867
4868    //-------------------------------------------------------------------------
4869    // Methods can be called from a separate thread, like WebViewCore
4870    // If it needs to call the View system, it has to send message.
4871    //-------------------------------------------------------------------------
4872
4873    /**
4874     * General handler to receive message coming from webkit thread
4875     */
4876    class PrivateHandler extends Handler {
4877        @Override
4878        public void handleMessage(Message msg) {
4879            if (DebugFlags.WEB_VIEW) {
4880                Log.v(LOGTAG, msg.what < REMEMBER_PASSWORD || msg.what
4881                        > INVAL_RECT_MSG_ID ? Integer.toString(msg.what)
4882                        : HandlerDebugString[msg.what - REMEMBER_PASSWORD]);
4883            }
4884            if (mWebViewCore == null) {
4885                // after WebView's destroy() is called, skip handling messages.
4886                return;
4887            }
4888            switch (msg.what) {
4889                case REMEMBER_PASSWORD: {
4890                    mDatabase.setUsernamePassword(
4891                            msg.getData().getString("host"),
4892                            msg.getData().getString("username"),
4893                            msg.getData().getString("password"));
4894                    ((Message) msg.obj).sendToTarget();
4895                    break;
4896                }
4897                case NEVER_REMEMBER_PASSWORD: {
4898                    mDatabase.setUsernamePassword(
4899                            msg.getData().getString("host"), null, null);
4900                    ((Message) msg.obj).sendToTarget();
4901                    break;
4902                }
4903                case SWITCH_TO_SHORTPRESS: {
4904                    // if mPreventDrag is not confirmed, treat it as no so that
4905                    // it won't block panning the page.
4906                    if (mPreventDrag == PREVENT_DRAG_MAYBE_YES) {
4907                        mPreventDrag = PREVENT_DRAG_NO;
4908                    }
4909                    if (mTouchMode == TOUCH_INIT_MODE) {
4910                        mTouchMode = TOUCH_SHORTPRESS_START_MODE;
4911                        updateSelection();
4912                    } else if (mTouchMode == TOUCH_DOUBLE_TAP_MODE) {
4913                        mTouchMode = TOUCH_DONE_MODE;
4914                    }
4915                    break;
4916                }
4917                case SWITCH_TO_LONGPRESS: {
4918                    if (mPreventDrag == PREVENT_DRAG_NO) {
4919                        mTouchMode = TOUCH_DONE_MODE;
4920                        performLongClick();
4921                        rebuildWebTextView();
4922                    }
4923                    break;
4924                }
4925                case RELEASE_SINGLE_TAP: {
4926                    if (mPreventDrag == PREVENT_DRAG_NO) {
4927                        mTouchMode = TOUCH_DONE_MODE;
4928                        doShortPress();
4929                    }
4930                    break;
4931                }
4932                case SCROLL_BY_MSG_ID:
4933                    setContentScrollBy(msg.arg1, msg.arg2, (Boolean) msg.obj);
4934                    break;
4935                case SYNC_SCROLL_TO_MSG_ID:
4936                    if (mUserScroll) {
4937                        // if user has scrolled explicitly, don't sync the
4938                        // scroll position any more
4939                        mUserScroll = false;
4940                        break;
4941                    }
4942                    // fall through
4943                case SCROLL_TO_MSG_ID:
4944                    if (setContentScrollTo(msg.arg1, msg.arg2)) {
4945                        // if we can't scroll to the exact position due to pin,
4946                        // send a message to WebCore to re-scroll when we get a
4947                        // new picture
4948                        mUserScroll = false;
4949                        mWebViewCore.sendMessage(EventHub.SYNC_SCROLL,
4950                                msg.arg1, msg.arg2);
4951                    }
4952                    break;
4953                case SPAWN_SCROLL_TO_MSG_ID:
4954                    spawnContentScrollTo(msg.arg1, msg.arg2);
4955                    break;
4956                case NEW_PICTURE_MSG_ID: {
4957                    WebSettings settings = mWebViewCore.getSettings();
4958                    // called for new content
4959                    final int viewWidth = getViewWidth();
4960                    final WebViewCore.DrawData draw =
4961                            (WebViewCore.DrawData) msg.obj;
4962                    final Point viewSize = draw.mViewPoint;
4963                    boolean useWideViewport = settings.getUseWideViewPort();
4964                    WebViewCore.RestoreState restoreState = draw.mRestoreState;
4965                    if (restoreState != null) {
4966                        mInZoomOverview = false;
4967                        mLastScale = restoreState.mTextWrapScale;
4968                        if (restoreState.mMinScale == 0) {
4969                            if (restoreState.mMobileSite) {
4970                                if (draw.mMinPrefWidth >
4971                                        Math.max(0, draw.mViewPoint.x)) {
4972                                    mMinZoomScale = (float) viewWidth
4973                                            / draw.mMinPrefWidth;
4974                                    mMinZoomScaleFixed = false;
4975                                } else {
4976                                    mMinZoomScale = restoreState.mDefaultScale;
4977                                    mMinZoomScaleFixed = true;
4978                                }
4979                            } else {
4980                                mMinZoomScale = DEFAULT_MIN_ZOOM_SCALE;
4981                                mMinZoomScaleFixed = false;
4982                            }
4983                        } else {
4984                            mMinZoomScale = restoreState.mMinScale;
4985                            mMinZoomScaleFixed = true;
4986                        }
4987                        if (restoreState.mMaxScale == 0) {
4988                            mMaxZoomScale = DEFAULT_MAX_ZOOM_SCALE;
4989                        } else {
4990                            mMaxZoomScale = restoreState.mMaxScale;
4991                        }
4992                        setNewZoomScale(mLastScale, false);
4993                        setContentScrollTo(restoreState.mScrollX,
4994                                restoreState.mScrollY);
4995                        if (useWideViewport
4996                                && settings.getLoadWithOverviewMode()) {
4997                            if (restoreState.mViewScale == 0
4998                                    || (restoreState.mMobileSite
4999                                    && mMinZoomScale < restoreState.mDefaultScale)) {
5000                                mInZoomOverview = true;
5001                            }
5002                        }
5003                        // As we are on a new page, remove the WebTextView. This
5004                        // is necessary for page loads driven by webkit, and in
5005                        // particular when the user was on a password field, so
5006                        // the WebTextView was visible.
5007                        clearTextEntry();
5008                    }
5009                    // We update the layout (i.e. request a layout from the
5010                    // view system) if the last view size that we sent to
5011                    // WebCore matches the view size of the picture we just
5012                    // received in the fixed dimension.
5013                    final boolean updateLayout = viewSize.x == mLastWidthSent
5014                            && viewSize.y == mLastHeightSent;
5015                    recordNewContentSize(draw.mWidthHeight.x,
5016                            draw.mWidthHeight.y
5017                            + (mFindIsUp ? mFindHeight : 0), updateLayout);
5018                    if (DebugFlags.WEB_VIEW) {
5019                        Rect b = draw.mInvalRegion.getBounds();
5020                        Log.v(LOGTAG, "NEW_PICTURE_MSG_ID {" +
5021                                b.left+","+b.top+","+b.right+","+b.bottom+"}");
5022                    }
5023                    invalidateContentRect(draw.mInvalRegion.getBounds());
5024                    if (mPictureListener != null) {
5025                        mPictureListener.onNewPicture(WebView.this, capturePicture());
5026                    }
5027                    if (useWideViewport) {
5028                        mZoomOverviewWidth = Math.max(draw.mMinPrefWidth,
5029                                draw.mViewPoint.x);
5030                    }
5031                    if (!mMinZoomScaleFixed) {
5032                        mMinZoomScale = (float) viewWidth / mZoomOverviewWidth;
5033                    }
5034                    if (!mDrawHistory && mInZoomOverview) {
5035                        // fit the content width to the current view. Ignore
5036                        // the rounding error case.
5037                        if (Math.abs((viewWidth * mInvActualScale)
5038                                - mZoomOverviewWidth) > 1) {
5039                            setNewZoomScale((float) viewWidth
5040                                    / mZoomOverviewWidth, false);
5041                        }
5042                    }
5043                    break;
5044                }
5045                case WEBCORE_INITIALIZED_MSG_ID:
5046                    // nativeCreate sets mNativeClass to a non-zero value
5047                    nativeCreate(msg.arg1);
5048                    break;
5049                case UPDATE_TEXTFIELD_TEXT_MSG_ID:
5050                    // Make sure that the textfield is currently focused
5051                    // and representing the same node as the pointer.
5052                    if (inEditingMode() &&
5053                            mWebTextView.isSameTextField(msg.arg1)) {
5054                        if (msg.getData().getBoolean("password")) {
5055                            Spannable text = (Spannable) mWebTextView.getText();
5056                            int start = Selection.getSelectionStart(text);
5057                            int end = Selection.getSelectionEnd(text);
5058                            mWebTextView.setInPassword(true);
5059                            // Restore the selection, which may have been
5060                            // ruined by setInPassword.
5061                            Spannable pword =
5062                                    (Spannable) mWebTextView.getText();
5063                            Selection.setSelection(pword, start, end);
5064                        // If the text entry has created more events, ignore
5065                        // this one.
5066                        } else if (msg.arg2 == mTextGeneration) {
5067                            mWebTextView.setTextAndKeepSelection(
5068                                    (String) msg.obj);
5069                        }
5070                    }
5071                    break;
5072                case UPDATE_TEXT_SELECTION_MSG_ID:
5073                    if (inEditingMode()
5074                            && mWebTextView.isSameTextField(msg.arg1)
5075                            && msg.arg2 == mTextGeneration) {
5076                        WebViewCore.TextSelectionData tData
5077                                = (WebViewCore.TextSelectionData) msg.obj;
5078                        mWebTextView.setSelectionFromWebKit(tData.mStart,
5079                                tData.mEnd);
5080                    }
5081                    break;
5082                case MOVE_OUT_OF_PLUGIN:
5083                    if (nativePluginEatsNavKey()) {
5084                        navHandledKey(msg.arg1, 1, false, 0, true);
5085                    }
5086                    break;
5087                case UPDATE_TEXT_ENTRY_MSG_ID:
5088                    // this is sent after finishing resize in WebViewCore. Make
5089                    // sure the text edit box is still on the  screen.
5090                    if (inEditingMode() && nativeCursorIsTextInput()) {
5091                        mWebTextView.bringIntoView();
5092                        rebuildWebTextView();
5093                    }
5094                    break;
5095                case CLEAR_TEXT_ENTRY:
5096                    clearTextEntry();
5097                    break;
5098                case INVAL_RECT_MSG_ID: {
5099                    Rect r = (Rect)msg.obj;
5100                    if (r == null) {
5101                        invalidate();
5102                    } else {
5103                        // we need to scale r from content into view coords,
5104                        // which viewInvalidate() does for us
5105                        viewInvalidate(r.left, r.top, r.right, r.bottom);
5106                    }
5107                    break;
5108                }
5109                case REQUEST_FORM_DATA:
5110                    AutoCompleteAdapter adapter = (AutoCompleteAdapter) msg.obj;
5111                    if (mWebTextView.isSameTextField(msg.arg1)) {
5112                        mWebTextView.setAdapterCustom(adapter);
5113                    }
5114                    break;
5115                case UPDATE_CLIPBOARD:
5116                    String str = (String) msg.obj;
5117                    if (DebugFlags.WEB_VIEW) {
5118                        Log.v(LOGTAG, "UPDATE_CLIPBOARD " + str);
5119                    }
5120                    try {
5121                        IClipboard clip = IClipboard.Stub.asInterface(
5122                                ServiceManager.getService("clipboard"));
5123                                clip.setClipboardText(str);
5124                    } catch (android.os.RemoteException e) {
5125                        Log.e(LOGTAG, "Clipboard failed", e);
5126                    }
5127                    break;
5128                case RESUME_WEBCORE_UPDATE:
5129                    WebViewCore.resumeUpdate(mWebViewCore);
5130                    break;
5131
5132                case LONG_PRESS_CENTER:
5133                    // as this is shared by keydown and trackballdown, reset all
5134                    // the states
5135                    mGotCenterDown = false;
5136                    mTrackballDown = false;
5137                    // LONG_PRESS_CENTER is sent as a delayed message. If we
5138                    // switch to windows overview, the WebView will be
5139                    // temporarily removed from the view system. In that case,
5140                    // do nothing.
5141                    if (getParent() != null) {
5142                        performLongClick();
5143                    }
5144                    break;
5145
5146                case WEBCORE_NEED_TOUCH_EVENTS:
5147                    mForwardTouchEvents = (msg.arg1 != 0);
5148                    break;
5149
5150                case PREVENT_TOUCH_ID:
5151                    if (msg.arg1 == MotionEvent.ACTION_DOWN) {
5152                        // dont override if mPreventDrag has been set to no due
5153                        // to time out
5154                        if (mPreventDrag == PREVENT_DRAG_MAYBE_YES) {
5155                            mPreventDrag = msg.arg2 == 1 ? PREVENT_DRAG_YES
5156                                    : PREVENT_DRAG_NO;
5157                            if (mPreventDrag == PREVENT_DRAG_YES) {
5158                                mTouchMode = TOUCH_DONE_MODE;
5159                            }
5160                        }
5161                    }
5162                    break;
5163
5164                case REQUEST_KEYBOARD:
5165                    if (msg.arg1 == 0) {
5166                        hideSoftKeyboard();
5167                    } else {
5168                        displaySoftKeyboard(false);
5169                    }
5170                    break;
5171
5172                default:
5173                    super.handleMessage(msg);
5174                    break;
5175            }
5176        }
5177    }
5178
5179    // Class used to use a dropdown for a <select> element
5180    private class InvokeListBox implements Runnable {
5181        // Whether the listbox allows multiple selection.
5182        private boolean     mMultiple;
5183        // Passed in to a list with multiple selection to tell
5184        // which items are selected.
5185        private int[]       mSelectedArray;
5186        // Passed in to a list with single selection to tell
5187        // where the initial selection is.
5188        private int         mSelection;
5189
5190        private Container[] mContainers;
5191
5192        // Need these to provide stable ids to my ArrayAdapter,
5193        // which normally does not have stable ids. (Bug 1250098)
5194        private class Container extends Object {
5195            String  mString;
5196            boolean mEnabled;
5197            int     mId;
5198
5199            public String toString() {
5200                return mString;
5201            }
5202        }
5203
5204        /**
5205         *  Subclass ArrayAdapter so we can disable OptionGroupLabels,
5206         *  and allow filtering.
5207         */
5208        private class MyArrayListAdapter extends ArrayAdapter<Container> {
5209            public MyArrayListAdapter(Context context, Container[] objects, boolean multiple) {
5210                super(context,
5211                            multiple ? com.android.internal.R.layout.select_dialog_multichoice :
5212                            com.android.internal.R.layout.select_dialog_singlechoice,
5213                            objects);
5214            }
5215
5216            @Override
5217            public boolean hasStableIds() {
5218                // AdapterView's onChanged method uses this to determine whether
5219                // to restore the old state.  Return false so that the old (out
5220                // of date) state does not replace the new, valid state.
5221                return false;
5222            }
5223
5224            private Container item(int position) {
5225                if (position < 0 || position >= getCount()) {
5226                    return null;
5227                }
5228                return (Container) getItem(position);
5229            }
5230
5231            @Override
5232            public long getItemId(int position) {
5233                Container item = item(position);
5234                if (item == null) {
5235                    return -1;
5236                }
5237                return item.mId;
5238            }
5239
5240            @Override
5241            public boolean areAllItemsEnabled() {
5242                return false;
5243            }
5244
5245            @Override
5246            public boolean isEnabled(int position) {
5247                Container item = item(position);
5248                if (item == null) {
5249                    return false;
5250                }
5251                return item.mEnabled;
5252            }
5253        }
5254
5255        private InvokeListBox(String[] array,
5256                boolean[] enabled, int[] selected) {
5257            mMultiple = true;
5258            mSelectedArray = selected;
5259
5260            int length = array.length;
5261            mContainers = new Container[length];
5262            for (int i = 0; i < length; i++) {
5263                mContainers[i] = new Container();
5264                mContainers[i].mString = array[i];
5265                mContainers[i].mEnabled = enabled[i];
5266                mContainers[i].mId = i;
5267            }
5268        }
5269
5270        private InvokeListBox(String[] array, boolean[] enabled, int
5271                selection) {
5272            mSelection = selection;
5273            mMultiple = false;
5274
5275            int length = array.length;
5276            mContainers = new Container[length];
5277            for (int i = 0; i < length; i++) {
5278                mContainers[i] = new Container();
5279                mContainers[i].mString = array[i];
5280                mContainers[i].mEnabled = enabled[i];
5281                mContainers[i].mId = i;
5282            }
5283        }
5284
5285        /*
5286         * Whenever the data set changes due to filtering, this class ensures
5287         * that the checked item remains checked.
5288         */
5289        private class SingleDataSetObserver extends DataSetObserver {
5290            private long        mCheckedId;
5291            private ListView    mListView;
5292            private Adapter     mAdapter;
5293
5294            /*
5295             * Create a new observer.
5296             * @param id The ID of the item to keep checked.
5297             * @param l ListView for getting and clearing the checked states
5298             * @param a Adapter for getting the IDs
5299             */
5300            public SingleDataSetObserver(long id, ListView l, Adapter a) {
5301                mCheckedId = id;
5302                mListView = l;
5303                mAdapter = a;
5304            }
5305
5306            public void onChanged() {
5307                // The filter may have changed which item is checked.  Find the
5308                // item that the ListView thinks is checked.
5309                int position = mListView.getCheckedItemPosition();
5310                long id = mAdapter.getItemId(position);
5311                if (mCheckedId != id) {
5312                    // Clear the ListView's idea of the checked item, since
5313                    // it is incorrect
5314                    mListView.clearChoices();
5315                    // Search for mCheckedId.  If it is in the filtered list,
5316                    // mark it as checked
5317                    int count = mAdapter.getCount();
5318                    for (int i = 0; i < count; i++) {
5319                        if (mAdapter.getItemId(i) == mCheckedId) {
5320                            mListView.setItemChecked(i, true);
5321                            break;
5322                        }
5323                    }
5324                }
5325            }
5326
5327            public void onInvalidate() {}
5328        }
5329
5330        public void run() {
5331            final ListView listView = (ListView) LayoutInflater.from(mContext)
5332                    .inflate(com.android.internal.R.layout.select_dialog, null);
5333            final MyArrayListAdapter adapter = new
5334                    MyArrayListAdapter(mContext, mContainers, mMultiple);
5335            AlertDialog.Builder b = new AlertDialog.Builder(mContext)
5336                    .setView(listView).setCancelable(true)
5337                    .setInverseBackgroundForced(true);
5338
5339            if (mMultiple) {
5340                b.setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {
5341                    public void onClick(DialogInterface dialog, int which) {
5342                        mWebViewCore.sendMessage(
5343                                EventHub.LISTBOX_CHOICES,
5344                                adapter.getCount(), 0,
5345                                listView.getCheckedItemPositions());
5346                    }});
5347                b.setNegativeButton(android.R.string.cancel,
5348                        new DialogInterface.OnClickListener() {
5349                    public void onClick(DialogInterface dialog, int which) {
5350                        mWebViewCore.sendMessage(
5351                                EventHub.SINGLE_LISTBOX_CHOICE, -2, 0);
5352                }});
5353            }
5354            final AlertDialog dialog = b.create();
5355            listView.setAdapter(adapter);
5356            listView.setFocusableInTouchMode(true);
5357            // There is a bug (1250103) where the checks in a ListView with
5358            // multiple items selected are associated with the positions, not
5359            // the ids, so the items do not properly retain their checks when
5360            // filtered.  Do not allow filtering on multiple lists until
5361            // that bug is fixed.
5362
5363            listView.setTextFilterEnabled(!mMultiple);
5364            if (mMultiple) {
5365                listView.setChoiceMode(ListView.CHOICE_MODE_MULTIPLE);
5366                int length = mSelectedArray.length;
5367                for (int i = 0; i < length; i++) {
5368                    listView.setItemChecked(mSelectedArray[i], true);
5369                }
5370            } else {
5371                listView.setOnItemClickListener(new OnItemClickListener() {
5372                    public void onItemClick(AdapterView parent, View v,
5373                            int position, long id) {
5374                        mWebViewCore.sendMessage(
5375                                EventHub.SINGLE_LISTBOX_CHOICE, (int)id, 0);
5376                        dialog.dismiss();
5377                    }
5378                });
5379                if (mSelection != -1) {
5380                    listView.setSelection(mSelection);
5381                    listView.setChoiceMode(ListView.CHOICE_MODE_SINGLE);
5382                    listView.setItemChecked(mSelection, true);
5383                    DataSetObserver observer = new SingleDataSetObserver(
5384                            adapter.getItemId(mSelection), listView, adapter);
5385                    adapter.registerDataSetObserver(observer);
5386                }
5387            }
5388            dialog.setOnCancelListener(new DialogInterface.OnCancelListener() {
5389                public void onCancel(DialogInterface dialog) {
5390                    mWebViewCore.sendMessage(
5391                                EventHub.SINGLE_LISTBOX_CHOICE, -2, 0);
5392                }
5393            });
5394            dialog.show();
5395        }
5396    }
5397
5398    /*
5399     * Request a dropdown menu for a listbox with multiple selection.
5400     *
5401     * @param array Labels for the listbox.
5402     * @param enabledArray  Which positions are enabled.
5403     * @param selectedArray Which positions are initally selected.
5404     */
5405    void requestListBox(String[] array, boolean[]enabledArray, int[]
5406            selectedArray) {
5407        mPrivateHandler.post(
5408                new InvokeListBox(array, enabledArray, selectedArray));
5409    }
5410
5411    /*
5412     * Request a dropdown menu for a listbox with single selection or a single
5413     * <select> element.
5414     *
5415     * @param array Labels for the listbox.
5416     * @param enabledArray  Which positions are enabled.
5417     * @param selection Which position is initally selected.
5418     */
5419    void requestListBox(String[] array, boolean[]enabledArray, int selection) {
5420        mPrivateHandler.post(
5421                new InvokeListBox(array, enabledArray, selection));
5422    }
5423
5424    // called by JNI
5425    private void sendMoveMouse(int frame, int node, int x, int y) {
5426        mWebViewCore.sendMessage(EventHub.SET_MOVE_MOUSE,
5427                new WebViewCore.CursorData(frame, node, x, y));
5428    }
5429
5430    /*
5431     * Send a mouse move event to the webcore thread.
5432     *
5433     * @param removeFocus Pass true if the "mouse" cursor is now over a node
5434     *                    which wants key events, but it is not the focus. This
5435     *                    will make the visual appear as though nothing is in
5436     *                    focus.  Remove the WebTextView, if present, and stop
5437     *                    drawing the blinking caret.
5438     * called by JNI
5439     */
5440    private void sendMoveMouseIfLatest(boolean removeFocus) {
5441        if (removeFocus) {
5442            clearTextEntry();
5443            setFocusControllerInactive();
5444        }
5445        mWebViewCore.sendMessage(EventHub.SET_MOVE_MOUSE_IF_LATEST,
5446                cursorData());
5447    }
5448
5449    // called by JNI
5450    private void sendMotionUp(int touchGeneration,
5451            int frame, int node, int x, int y) {
5452        WebViewCore.TouchUpData touchUpData = new WebViewCore.TouchUpData();
5453        touchUpData.mMoveGeneration = touchGeneration;
5454        touchUpData.mFrame = frame;
5455        touchUpData.mNode = node;
5456        touchUpData.mX = x;
5457        touchUpData.mY = y;
5458        mWebViewCore.sendMessage(EventHub.TOUCH_UP, touchUpData);
5459    }
5460
5461
5462    private int getScaledMaxXScroll() {
5463        int width;
5464        if (mHeightCanMeasure == false) {
5465            width = getViewWidth() / 4;
5466        } else {
5467            Rect visRect = new Rect();
5468            calcOurVisibleRect(visRect);
5469            width = visRect.width() / 2;
5470        }
5471        // FIXME the divisor should be retrieved from somewhere
5472        return viewToContentX(width);
5473    }
5474
5475    private int getScaledMaxYScroll() {
5476        int height;
5477        if (mHeightCanMeasure == false) {
5478            height = getViewHeight() / 4;
5479        } else {
5480            Rect visRect = new Rect();
5481            calcOurVisibleRect(visRect);
5482            height = visRect.height() / 2;
5483        }
5484        // FIXME the divisor should be retrieved from somewhere
5485        // the closest thing today is hard-coded into ScrollView.java
5486        // (from ScrollView.java, line 363)   int maxJump = height/2;
5487        return Math.round(height * mInvActualScale);
5488    }
5489
5490    /**
5491     * Called by JNI to invalidate view
5492     */
5493    private void viewInvalidate() {
5494        invalidate();
5495    }
5496
5497    // return true if the key was handled
5498    private boolean navHandledKey(int keyCode, int count, boolean noScroll,
5499            long time, boolean ignorePlugin) {
5500        if (mNativeClass == 0) {
5501            return false;
5502        }
5503        if (ignorePlugin == false && nativePluginEatsNavKey()) {
5504            KeyEvent event = new KeyEvent(time, time, KeyEvent.ACTION_DOWN
5505                , keyCode, count, (mShiftIsPressed ? KeyEvent.META_SHIFT_ON : 0)
5506                | (false ? KeyEvent.META_ALT_ON : 0) // FIXME
5507                | (false ? KeyEvent.META_SYM_ON : 0) // FIXME
5508                , 0, 0, 0);
5509            mWebViewCore.sendMessage(EventHub.KEY_DOWN, event);
5510            mWebViewCore.sendMessage(EventHub.KEY_UP, event);
5511            return true;
5512        }
5513        mLastCursorTime = time;
5514        mLastCursorBounds = nativeGetCursorRingBounds();
5515        boolean keyHandled
5516                = nativeMoveCursor(keyCode, count, noScroll) == false;
5517        if (DebugFlags.WEB_VIEW) {
5518            Log.v(LOGTAG, "navHandledKey mLastCursorBounds=" + mLastCursorBounds
5519                    + " mLastCursorTime=" + mLastCursorTime
5520                    + " handled=" + keyHandled);
5521        }
5522        if (keyHandled == false || mHeightCanMeasure == false) {
5523            return keyHandled;
5524        }
5525        Rect contentCursorRingBounds = nativeGetCursorRingBounds();
5526        if (contentCursorRingBounds.isEmpty()) return keyHandled;
5527        Rect viewCursorRingBounds = contentToViewRect(contentCursorRingBounds);
5528        Rect visRect = new Rect();
5529        calcOurVisibleRect(visRect);
5530        Rect outset = new Rect(visRect);
5531        int maxXScroll = visRect.width() / 2;
5532        int maxYScroll = visRect.height() / 2;
5533        outset.inset(-maxXScroll, -maxYScroll);
5534        if (Rect.intersects(outset, viewCursorRingBounds) == false) {
5535            return keyHandled;
5536        }
5537        // FIXME: Necessary because ScrollView/ListView do not scroll left/right
5538        int maxH = Math.min(viewCursorRingBounds.right - visRect.right,
5539                maxXScroll);
5540        if (maxH > 0) {
5541            pinScrollBy(maxH, 0, true, 0);
5542        } else {
5543            maxH = Math.max(viewCursorRingBounds.left - visRect.left,
5544                    -maxXScroll);
5545            if (maxH < 0) {
5546                pinScrollBy(maxH, 0, true, 0);
5547            }
5548        }
5549        if (mLastCursorBounds.isEmpty()) return keyHandled;
5550        if (mLastCursorBounds.equals(contentCursorRingBounds)) {
5551            return keyHandled;
5552        }
5553        if (DebugFlags.WEB_VIEW) {
5554            Log.v(LOGTAG, "navHandledKey contentCursorRingBounds="
5555                    + contentCursorRingBounds);
5556        }
5557        requestRectangleOnScreen(viewCursorRingBounds);
5558        mUserScroll = true;
5559        return keyHandled;
5560    }
5561
5562    /**
5563     * Set the background color. It's white by default. Pass
5564     * zero to make the view transparent.
5565     * @param color   the ARGB color described by Color.java
5566     */
5567    public void setBackgroundColor(int color) {
5568        mBackgroundColor = color;
5569        mWebViewCore.sendMessage(EventHub.SET_BACKGROUND_COLOR, color);
5570    }
5571
5572    public void debugDump() {
5573        nativeDebugDump();
5574        mWebViewCore.sendMessage(EventHub.DUMP_NAVTREE);
5575    }
5576
5577    /**
5578     *  Update our cache with updatedText.
5579     *  @param updatedText  The new text to put in our cache.
5580     */
5581    /* package */ void updateCachedTextfield(String updatedText) {
5582        // Also place our generation number so that when we look at the cache
5583        // we recognize that it is up to date.
5584        nativeUpdateCachedTextfield(updatedText, mTextGeneration);
5585    }
5586
5587    /* package */ native void nativeClearCursor();
5588    private native void     nativeCreate(int ptr);
5589    private native int      nativeCursorFramePointer();
5590    private native Rect     nativeCursorNodeBounds();
5591    /* package */ native int nativeCursorNodePointer();
5592    /* package */ native boolean nativeCursorMatchesFocus();
5593    private native boolean  nativeCursorIntersects(Rect visibleRect);
5594    private native boolean  nativeCursorIsAnchor();
5595    private native boolean  nativeCursorIsPlugin();
5596    private native boolean  nativeCursorIsTextInput();
5597    private native Point    nativeCursorPosition();
5598    private native String   nativeCursorText();
5599    /**
5600     * Returns true if the native cursor node says it wants to handle key events
5601     * (ala plugins). This can only be called if mNativeClass is non-zero!
5602     */
5603    private native boolean  nativeCursorWantsKeyEvents();
5604    private native void     nativeDebugDump();
5605    private native void     nativeDestroy();
5606    private native void     nativeDrawCursorRing(Canvas content);
5607    private native void     nativeDrawMatches(Canvas canvas);
5608    private native void     nativeDrawSelection(Canvas content, float scale,
5609            int offset, int x, int y, boolean extendSelection);
5610    private native void     nativeDrawSelectionRegion(Canvas content);
5611    private native void     nativeDumpDisplayTree(String urlOrNull);
5612    private native int      nativeFindAll(String findLower, String findUpper);
5613    private native void     nativeFindNext(boolean forward);
5614    private native boolean  nativeFocusCandidateIsPassword();
5615    private native boolean  nativeFocusCandidateIsRtlText();
5616    private native boolean  nativeFocusCandidateIsTextField();
5617    private native boolean  nativeFocusCandidateIsTextInput();
5618    private native int      nativeFocusCandidateMaxLength();
5619    /* package */ native String   nativeFocusCandidateName();
5620    private native Rect     nativeFocusCandidateNodeBounds();
5621    /* package */ native int nativeFocusCandidatePointer();
5622    private native String   nativeFocusCandidateText();
5623    private native int      nativeFocusCandidateTextSize();
5624    /* package */ native int nativeFocusNodePointer();
5625    private native Rect     nativeGetCursorRingBounds();
5626    private native Region   nativeGetSelection();
5627    private native boolean  nativeHasCursorNode();
5628    private native boolean  nativeHasFocusNode();
5629    private native void     nativeHideCursor();
5630    private native String   nativeImageURI(int x, int y);
5631    private native void     nativeInstrumentReport();
5632    /* package */ native void nativeMoveCursorToNextTextInput();
5633    // return true if the page has been scrolled
5634    private native boolean  nativeMotionUp(int x, int y, int slop);
5635    // returns false if it handled the key
5636    private native boolean  nativeMoveCursor(int keyCode, int count,
5637            boolean noScroll);
5638    private native int      nativeMoveGeneration();
5639    private native void     nativeMoveSelection(int x, int y,
5640            boolean extendSelection);
5641    private native boolean  nativePluginEatsNavKey();
5642    // Like many other of our native methods, you must make sure that
5643    // mNativeClass is not null before calling this method.
5644    private native void     nativeRecordButtons(boolean focused,
5645            boolean pressed, boolean invalidate);
5646    private native void     nativeSelectBestAt(Rect rect);
5647    private native void     nativeSetFindIsDown();
5648    private native void     nativeSetFollowedLink(boolean followed);
5649    private native void     nativeSetHeightCanMeasure(boolean measure);
5650    // Returns a value corresponding to CachedFrame::ImeAction
5651    /* package */ native int  nativeTextFieldAction();
5652    /**
5653     * Perform a click on a currently focused text input.  Since it is already
5654     * focused, there is no need to go through the nativeMotionUp code, which
5655     * may change the Cursor.
5656     */
5657    private native void     nativeTextInputMotionUp(int x, int y);
5658    private native int      nativeTextGeneration();
5659    // Never call this version except by updateCachedTextfield(String) -
5660    // we always want to pass in our generation number.
5661    private native void     nativeUpdateCachedTextfield(String updatedText,
5662            int generation);
5663    private native void     nativeUpdatePluginReceivesEvents();
5664    // return NO_LEFTEDGE means failure.
5665    private static final int NO_LEFTEDGE = -1;
5666    private native int      nativeGetBlockLeftEdge(int x, int y, float scale);
5667}
5668