Controller.java revision e28b347fcc1df6e6bd41cb294d521a4f1e7c5c75 
1/*
2 * Copyright (C) 2010 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 com.android.browser;
18
19import android.app.Activity;
20import android.app.DownloadManager;
21import android.app.SearchManager;
22import android.content.ClipboardManager;
23import android.content.ContentProvider;
24import android.content.ContentProviderClient;
25import android.content.ContentResolver;
26import android.content.ContentUris;
27import android.content.ContentValues;
28import android.content.Context;
29import android.content.Intent;
30import android.content.pm.PackageManager;
31import android.content.pm.ResolveInfo;
32import android.content.res.Configuration;
33import android.content.res.TypedArray;
34import android.database.ContentObserver;
35import android.database.Cursor;
36import android.database.sqlite.SQLiteDatabase;
37import android.graphics.Bitmap;
38import android.graphics.Canvas;
39import android.graphics.Picture;
40import android.net.Uri;
41import android.net.http.SslError;
42import android.os.AsyncTask;
43import android.os.Bundle;
44import android.os.Handler;
45import android.os.Message;
46import android.os.PowerManager;
47import android.os.PowerManager.WakeLock;
48import android.preference.PreferenceActivity;
49import android.provider.Browser;
50import android.provider.BrowserContract;
51import android.provider.BrowserContract.Images;
52import android.provider.ContactsContract;
53import android.provider.ContactsContract.Intents.Insert;
54import android.speech.RecognizerIntent;
55import android.text.TextUtils;
56import android.util.Log;
57import android.util.Patterns;
58import android.view.ActionMode;
59import android.view.ContextMenu;
60import android.view.ContextMenu.ContextMenuInfo;
61import android.view.Gravity;
62import android.view.KeyEvent;
63import android.view.Menu;
64import android.view.MenuInflater;
65import android.view.MenuItem;
66import android.view.MenuItem.OnMenuItemClickListener;
67import android.view.View;
68import android.webkit.CookieManager;
69import android.webkit.CookieSyncManager;
70import android.webkit.HttpAuthHandler;
71import android.webkit.SslErrorHandler;
72import android.webkit.ValueCallback;
73import android.webkit.WebChromeClient;
74import android.webkit.WebIconDatabase;
75import android.webkit.WebSettings;
76import android.webkit.WebView;
77import android.widget.Toast;
78
79import com.android.browser.IntentHandler.UrlData;
80import com.android.browser.UI.ComboViews;
81import com.android.browser.UI.DropdownChangeListener;
82import com.android.browser.provider.BrowserProvider;
83import com.android.browser.provider.BrowserProvider2.Thumbnails;
84import com.android.browser.provider.SnapshotProvider.Snapshots;
85import com.android.browser.search.SearchEngine;
86import com.android.common.Search;
87
88import java.io.ByteArrayOutputStream;
89import java.io.File;
90import java.net.URLEncoder;
91import java.util.ArrayList;
92import java.util.Calendar;
93import java.util.HashMap;
94import java.util.List;
95import java.util.Map;
96
97/**
98 * Controller for browser
99 */
100public class Controller
101        implements WebViewController, UiController {
102
103    private static final String LOGTAG = "Controller";
104    private static final String SEND_APP_ID_EXTRA =
105        "android.speech.extras.SEND_APPLICATION_ID_EXTRA";
106    private static final String INCOGNITO_URI = "browser:incognito";
107
108
109    // public message ids
110    public final static int LOAD_URL = 1001;
111    public final static int STOP_LOAD = 1002;
112
113    // Message Ids
114    private static final int FOCUS_NODE_HREF = 102;
115    private static final int RELEASE_WAKELOCK = 107;
116
117    static final int UPDATE_BOOKMARK_THUMBNAIL = 108;
118
119    private static final int OPEN_BOOKMARKS = 201;
120
121    private static final int EMPTY_MENU = -1;
122
123    // activity requestCode
124    final static int COMBO_VIEW = 1;
125    final static int PREFERENCES_PAGE = 3;
126    final static int FILE_SELECTED = 4;
127    final static int AUTOFILL_SETUP = 5;
128
129    private final static int WAKELOCK_TIMEOUT = 5 * 60 * 1000; // 5 minutes
130
131    // As the ids are dynamically created, we can't guarantee that they will
132    // be in sequence, so this static array maps ids to a window number.
133    final static private int[] WINDOW_SHORTCUT_ID_ARRAY =
134    { R.id.window_one_menu_id, R.id.window_two_menu_id,
135      R.id.window_three_menu_id, R.id.window_four_menu_id,
136      R.id.window_five_menu_id, R.id.window_six_menu_id,
137      R.id.window_seven_menu_id, R.id.window_eight_menu_id };
138
139    // "source" parameter for Google search through search key
140    final static String GOOGLE_SEARCH_SOURCE_SEARCHKEY = "browser-key";
141    // "source" parameter for Google search through simplily type
142    final static String GOOGLE_SEARCH_SOURCE_TYPE = "browser-type";
143
144    // "no-crash-recovery" parameter in intetnt to suppress crash recovery
145    final static String NO_CRASH_RECOVERY = "no-crash-recovery";
146
147    private Activity mActivity;
148    private UI mUi;
149    private TabControl mTabControl;
150    private BrowserSettings mSettings;
151    private WebViewFactory mFactory;
152
153    private WakeLock mWakeLock;
154
155    private UrlHandler mUrlHandler;
156    private UploadHandler mUploadHandler;
157    private IntentHandler mIntentHandler;
158    private PageDialogsHandler mPageDialogsHandler;
159    private NetworkStateHandler mNetworkHandler;
160    private NfcHandler mNfcHandler;
161
162    private Message mAutoFillSetupMessage;
163
164    private boolean mShouldShowErrorConsole;
165
166    private SystemAllowGeolocationOrigins mSystemAllowGeolocationOrigins;
167
168    // FIXME, temp address onPrepareMenu performance problem.
169    // When we move everything out of view, we should rewrite this.
170    private int mCurrentMenuState = 0;
171    private int mMenuState = R.id.MAIN_MENU;
172    private int mOldMenuState = EMPTY_MENU;
173    private Menu mCachedMenu;
174
175    private boolean mMenuIsDown;
176
177    // For select and find, we keep track of the ActionMode so that
178    // finish() can be called as desired.
179    private ActionMode mActionMode;
180
181    /**
182     * Only meaningful when mOptionsMenuOpen is true.  This variable keeps track
183     * of whether the configuration has changed.  The first onMenuOpened call
184     * after a configuration change is simply a reopening of the same menu
185     * (i.e. mIconView did not change).
186     */
187    private boolean mConfigChanged;
188
189    /**
190     * Keeps track of whether the options menu is open. This is important in
191     * determining whether to show or hide the title bar overlay
192     */
193    private boolean mOptionsMenuOpen;
194
195    /**
196     * Whether or not the options menu is in its bigger, popup menu form. When
197     * true, we want the title bar overlay to be gone. When false, we do not.
198     * Only meaningful if mOptionsMenuOpen is true.
199     */
200    private boolean mExtendedMenuOpen;
201
202    private boolean mInLoad;
203
204    private boolean mActivityPaused = true;
205    private boolean mLoadStopped;
206
207    private Handler mHandler;
208    // Checks to see when the bookmarks database has changed, and updates the
209    // Tabs' notion of whether they represent bookmarked sites.
210    private ContentObserver mBookmarksObserver;
211    private CrashRecoveryHandler mCrashRecoveryHandler;
212
213    private boolean mSimulateActionBarOverlayMode;
214
215    private static class ClearThumbnails extends AsyncTask<File, Void, Void> {
216        @Override
217        public Void doInBackground(File... files) {
218            if (files != null) {
219                for (File f : files) {
220                    if (!f.delete()) {
221                        Log.e(LOGTAG, f.getPath() + " was not deleted");
222                    }
223                }
224            }
225            return null;
226        }
227    }
228
229    public Controller(Activity browser, boolean preloadCrashState) {
230        mActivity = browser;
231        mSettings = BrowserSettings.getInstance();
232        mTabControl = new TabControl(this);
233        mSettings.setController(this);
234        mCrashRecoveryHandler = CrashRecoveryHandler.initialize(this);
235        if (preloadCrashState) {
236            mCrashRecoveryHandler.preloadCrashState();
237        }
238        mFactory = new BrowserWebViewFactory(browser);
239
240        mUrlHandler = new UrlHandler(this);
241        mIntentHandler = new IntentHandler(mActivity, this);
242        mPageDialogsHandler = new PageDialogsHandler(mActivity, this);
243        mNfcHandler = new NfcHandler(mActivity, this);
244
245        startHandler();
246        mBookmarksObserver = new ContentObserver(mHandler) {
247            @Override
248            public void onChange(boolean selfChange) {
249                int size = mTabControl.getTabCount();
250                for (int i = 0; i < size; i++) {
251                    mTabControl.getTab(i).updateBookmarkedStatus();
252                }
253            }
254
255        };
256        browser.getContentResolver().registerContentObserver(
257                BrowserContract.Bookmarks.CONTENT_URI, true, mBookmarksObserver);
258
259        mNetworkHandler = new NetworkStateHandler(mActivity, this);
260        // Start watching the default geolocation permissions
261        mSystemAllowGeolocationOrigins =
262                new SystemAllowGeolocationOrigins(mActivity.getApplicationContext());
263        mSystemAllowGeolocationOrigins.start();
264
265        openIconDatabase();
266        mSimulateActionBarOverlayMode = !BrowserActivity.isTablet(mActivity);
267    }
268
269    void start(final Bundle icicle, final Intent intent) {
270        boolean noCrashRecovery = intent.getBooleanExtra(NO_CRASH_RECOVERY, false);
271        if (icicle != null || noCrashRecovery) {
272            doStart(icicle, intent);
273        } else {
274            mCrashRecoveryHandler.startRecovery(intent);
275        }
276    }
277
278    void doStart(final Bundle icicle, final Intent intent) {
279        // Unless the last browser usage was within 24 hours, destroy any
280        // remaining incognito tabs.
281
282        Calendar lastActiveDate = icicle != null ?
283                (Calendar) icicle.getSerializable("lastActiveDate") : null;
284        Calendar today = Calendar.getInstance();
285        Calendar yesterday = Calendar.getInstance();
286        yesterday.add(Calendar.DATE, -1);
287
288        final boolean restoreIncognitoTabs = !(lastActiveDate == null
289            || lastActiveDate.before(yesterday)
290            || lastActiveDate.after(today));
291
292        // Find out if we will restore any state and remember the tab.
293        final long currentTabId =
294                mTabControl.canRestoreState(icicle, restoreIncognitoTabs);
295
296        if (currentTabId == -1) {
297            // Not able to restore so we go ahead and clear session cookies.  We
298            // must do this before trying to login the user as we don't want to
299            // clear any session cookies set during login.
300            CookieManager.getInstance().removeSessionCookie();
301        }
302
303        GoogleAccountLogin.startLoginIfNeeded(mActivity,
304                new Runnable() {
305                    @Override public void run() {
306                        onPreloginFinished(icicle, intent, currentTabId, restoreIncognitoTabs);
307                    }
308                });
309    }
310
311    private void onPreloginFinished(Bundle icicle, Intent intent, long currentTabId,
312            boolean restoreIncognitoTabs) {
313        if (currentTabId == -1) {
314            BackgroundHandler.execute(new PruneThumbnails(mActivity, null));
315            final Bundle extra = intent.getExtras();
316            // Create an initial tab.
317            // If the intent is ACTION_VIEW and data is not null, the Browser is
318            // invoked to view the content by another application. In this case,
319            // the tab will be close when exit.
320            UrlData urlData = IntentHandler.getUrlDataFromIntent(intent);
321            Tab t = null;
322            if (urlData.isEmpty()) {
323                t = openTabToHomePage();
324            } else {
325                t = openTab(urlData);
326            }
327            if (t != null) {
328                t.setAppId(intent.getStringExtra(Browser.EXTRA_APPLICATION_ID));
329            }
330            WebView webView = t.getWebView();
331            if (extra != null) {
332                int scale = extra.getInt(Browser.INITIAL_ZOOM_LEVEL, 0);
333                if (scale > 0 && scale <= 1000) {
334                    webView.setInitialScale(scale);
335                }
336            }
337            mUi.updateTabs(mTabControl.getTabs());
338        } else {
339            mTabControl.restoreState(icicle, currentTabId, restoreIncognitoTabs,
340                    mUi.needsRestoreAllTabs());
341            List<Tab> tabs = mTabControl.getTabs();
342            ArrayList<Long> restoredTabs = new ArrayList<Long>(tabs.size());
343            for (Tab t : tabs) {
344                restoredTabs.add(t.getId());
345            }
346            BackgroundHandler.execute(new PruneThumbnails(mActivity, restoredTabs));
347            mUi.updateTabs(tabs);
348            // TabControl.restoreState() will create a new tab even if
349            // restoring the state fails.
350            setActiveTab(mTabControl.getCurrentTab());
351            // Handle the intent
352            mIntentHandler.onNewIntent(intent);
353        }
354        // clear up the thumbnail directory, which is no longer used;
355        // ideally this should only be run once after an upgrade from
356        // a previous version of the browser
357        new ClearThumbnails().execute(mTabControl.getThumbnailDir()
358                .listFiles());
359        // Read JavaScript flags if it exists.
360        String jsFlags = getSettings().getJsEngineFlags();
361        if (jsFlags.trim().length() != 0) {
362            getCurrentWebView().setJsFlags(jsFlags);
363        }
364        if (BrowserActivity.ACTION_SHOW_BOOKMARKS.equals(intent.getAction())) {
365            bookmarksOrHistoryPicker(false);
366        }
367    }
368
369    private static class PruneThumbnails implements Runnable {
370        private Context mContext;
371        private List<Long> mIds;
372
373        PruneThumbnails(Context context, List<Long> preserveIds) {
374            mContext = context.getApplicationContext();
375            mIds = preserveIds;
376        }
377
378        @Override
379        public void run() {
380            ContentResolver cr = mContext.getContentResolver();
381            if (mIds == null || mIds.size() == 0) {
382                cr.delete(Thumbnails.CONTENT_URI, null, null);
383            } else {
384                int length = mIds.size();
385                StringBuilder where = new StringBuilder();
386                where.append(Thumbnails._ID);
387                where.append(" not in (");
388                for (int i = 0; i < length; i++) {
389                    where.append(mIds.get(i));
390                    if (i < (length - 1)) {
391                        where.append(",");
392                    }
393                }
394                where.append(")");
395                cr.delete(Thumbnails.CONTENT_URI, where.toString(), null);
396            }
397        }
398
399    }
400
401    @Override
402    public WebViewFactory getWebViewFactory() {
403        return mFactory;
404    }
405
406    @Override
407    public void onSetWebView(Tab tab, WebView view) {
408        mUi.onSetWebView(tab, view);
409    }
410
411    @Override
412    public void createSubWindow(Tab tab) {
413        endActionMode();
414        WebView mainView = tab.getWebView();
415        WebView subView = mFactory.createWebView((mainView == null)
416                ? false
417                : mainView.isPrivateBrowsingEnabled());
418        mUi.createSubWindow(tab, subView);
419    }
420
421    @Override
422    public Context getContext() {
423        return mActivity;
424    }
425
426    @Override
427    public Activity getActivity() {
428        return mActivity;
429    }
430
431    void setUi(UI ui) {
432        mUi = ui;
433    }
434
435    BrowserSettings getSettings() {
436        return mSettings;
437    }
438
439    IntentHandler getIntentHandler() {
440        return mIntentHandler;
441    }
442
443    @Override
444    public UI getUi() {
445        return mUi;
446    }
447
448    int getMaxTabs() {
449        return mActivity.getResources().getInteger(R.integer.max_tabs);
450    }
451
452    @Override
453    public TabControl getTabControl() {
454        return mTabControl;
455    }
456
457    @Override
458    public List<Tab> getTabs() {
459        return mTabControl.getTabs();
460    }
461
462    // Open the icon database.
463    private void openIconDatabase() {
464        // We have to call getInstance on the UI thread
465        final WebIconDatabase instance = WebIconDatabase.getInstance();
466        BackgroundHandler.execute(new Runnable() {
467
468            @Override
469            public void run() {
470                instance.open(mActivity.getDir("icons", 0).getPath());
471            }
472        });
473    }
474
475    private void startHandler() {
476        mHandler = new Handler() {
477
478            @Override
479            public void handleMessage(Message msg) {
480                switch (msg.what) {
481                    case OPEN_BOOKMARKS:
482                        bookmarksOrHistoryPicker(false);
483                        break;
484                    case FOCUS_NODE_HREF:
485                    {
486                        String url = (String) msg.getData().get("url");
487                        String title = (String) msg.getData().get("title");
488                        String src = (String) msg.getData().get("src");
489                        if (url == "") url = src; // use image if no anchor
490                        if (TextUtils.isEmpty(url)) {
491                            break;
492                        }
493                        HashMap focusNodeMap = (HashMap) msg.obj;
494                        WebView view = (WebView) focusNodeMap.get("webview");
495                        // Only apply the action if the top window did not change.
496                        if (getCurrentTopWebView() != view) {
497                            break;
498                        }
499                        switch (msg.arg1) {
500                            case R.id.open_context_menu_id:
501                                loadUrlFromContext(url);
502                                break;
503                            case R.id.view_image_context_menu_id:
504                                loadUrlFromContext(src);
505                                break;
506                            case R.id.open_newtab_context_menu_id:
507                                final Tab parent = mTabControl.getCurrentTab();
508                                openTab(url, parent,
509                                        !mSettings.openInBackground(), true);
510                                break;
511                            case R.id.copy_link_context_menu_id:
512                                copy(url);
513                                break;
514                            case R.id.save_link_context_menu_id:
515                            case R.id.download_context_menu_id:
516                                DownloadHandler.onDownloadStartNoStream(
517                                        mActivity, url, null, null, null,
518                                        view.isPrivateBrowsingEnabled());
519                                break;
520                        }
521                        break;
522                    }
523
524                    case LOAD_URL:
525                        loadUrlFromContext((String) msg.obj);
526                        break;
527
528                    case STOP_LOAD:
529                        stopLoading();
530                        break;
531
532                    case RELEASE_WAKELOCK:
533                        if (mWakeLock != null && mWakeLock.isHeld()) {
534                            mWakeLock.release();
535                            // if we reach here, Browser should be still in the
536                            // background loading after WAKELOCK_TIMEOUT (5-min).
537                            // To avoid burning the battery, stop loading.
538                            mTabControl.stopAllLoading();
539                        }
540                        break;
541
542                    case UPDATE_BOOKMARK_THUMBNAIL:
543                        Tab tab = (Tab) msg.obj;
544                        if (tab != null) {
545                            updateScreenshot(tab);
546                        }
547                        break;
548                }
549            }
550        };
551
552    }
553
554    @Override
555    public Tab getCurrentTab() {
556        return mTabControl.getCurrentTab();
557    }
558
559    @Override
560    public void shareCurrentPage() {
561        shareCurrentPage(mTabControl.getCurrentTab());
562    }
563
564    private void shareCurrentPage(Tab tab) {
565        if (tab != null) {
566            sharePage(mActivity, tab.getTitle(),
567                    tab.getUrl(), tab.getFavicon(),
568                    createScreenshot(tab.getWebView(),
569                            getDesiredThumbnailWidth(mActivity),
570                            getDesiredThumbnailHeight(mActivity)));
571        }
572    }
573
574    /**
575     * Share a page, providing the title, url, favicon, and a screenshot.  Uses
576     * an {@link Intent} to launch the Activity chooser.
577     * @param c Context used to launch a new Activity.
578     * @param title Title of the page.  Stored in the Intent with
579     *          {@link Intent#EXTRA_SUBJECT}
580     * @param url URL of the page.  Stored in the Intent with
581     *          {@link Intent#EXTRA_TEXT}
582     * @param favicon Bitmap of the favicon for the page.  Stored in the Intent
583     *          with {@link Browser#EXTRA_SHARE_FAVICON}
584     * @param screenshot Bitmap of a screenshot of the page.  Stored in the
585     *          Intent with {@link Browser#EXTRA_SHARE_SCREENSHOT}
586     */
587    static final void sharePage(Context c, String title, String url,
588            Bitmap favicon, Bitmap screenshot) {
589        Intent send = new Intent(Intent.ACTION_SEND);
590        send.setType("text/plain");
591        send.putExtra(Intent.EXTRA_TEXT, url);
592        send.putExtra(Intent.EXTRA_SUBJECT, title);
593        send.putExtra(Browser.EXTRA_SHARE_FAVICON, favicon);
594        send.putExtra(Browser.EXTRA_SHARE_SCREENSHOT, screenshot);
595        try {
596            c.startActivity(Intent.createChooser(send, c.getString(
597                    R.string.choosertitle_sharevia)));
598        } catch(android.content.ActivityNotFoundException ex) {
599            // if no app handles it, do nothing
600        }
601    }
602
603    private void copy(CharSequence text) {
604        ClipboardManager cm = (ClipboardManager) mActivity
605                .getSystemService(Context.CLIPBOARD_SERVICE);
606        cm.setText(text);
607    }
608
609    // lifecycle
610
611    protected void onConfgurationChanged(Configuration config) {
612        mConfigChanged = true;
613        if (mPageDialogsHandler != null) {
614            mPageDialogsHandler.onConfigurationChanged(config);
615        }
616        mUi.onConfigurationChanged(config);
617    }
618
619    @Override
620    public void handleNewIntent(Intent intent) {
621        mIntentHandler.onNewIntent(intent);
622    }
623
624    protected void onPause() {
625        if (mUi.isCustomViewShowing()) {
626            hideCustomView();
627        }
628        if (mActivityPaused) {
629            Log.e(LOGTAG, "BrowserActivity is already paused.");
630            return;
631        }
632        mActivityPaused = true;
633        Tab tab = mTabControl.getCurrentTab();
634        if (tab != null) {
635            tab.pause();
636            if (!pauseWebViewTimers(tab)) {
637                if (mWakeLock == null) {
638                    PowerManager pm = (PowerManager) mActivity
639                            .getSystemService(Context.POWER_SERVICE);
640                    mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "Browser");
641                }
642                mWakeLock.acquire();
643                mHandler.sendMessageDelayed(mHandler
644                        .obtainMessage(RELEASE_WAKELOCK), WAKELOCK_TIMEOUT);
645            }
646        }
647        mUi.onPause();
648        mNetworkHandler.onPause();
649        mNfcHandler.onPause();
650
651        WebView.disablePlatformNotifications();
652        mCrashRecoveryHandler.backupState();
653
654    }
655
656    void onSaveInstanceState(Bundle outState) {
657        // the default implementation requires each view to have an id. As the
658        // browser handles the state itself and it doesn't use id for the views,
659        // don't call the default implementation. Otherwise it will trigger the
660        // warning like this, "couldn't save which view has focus because the
661        // focused view XXX has no id".
662
663        // Save all the tabs
664        mTabControl.saveState(outState);
665        if (!outState.isEmpty()) {
666            // Save time so that we know how old incognito tabs (if any) are.
667            outState.putSerializable("lastActiveDate", Calendar.getInstance());
668        }
669    }
670
671    void onResume() {
672        if (!mActivityPaused) {
673            Log.e(LOGTAG, "BrowserActivity is already resumed.");
674            return;
675        }
676        mActivityPaused = false;
677        Tab current = mTabControl.getCurrentTab();
678        if (current != null) {
679            current.resume();
680            resumeWebViewTimers(current);
681        }
682        releaseWakeLock();
683
684        mUi.onResume();
685        mNetworkHandler.onResume();
686        mNfcHandler.onResume();
687        WebView.enablePlatformNotifications();
688    }
689
690    private void releaseWakeLock() {
691        if (mWakeLock != null && mWakeLock.isHeld()) {
692            mHandler.removeMessages(RELEASE_WAKELOCK);
693            mWakeLock.release();
694        }
695    }
696
697    /**
698     * resume all WebView timers using the WebView instance of the given tab
699     * @param tab guaranteed non-null
700     */
701    private void resumeWebViewTimers(Tab tab) {
702        boolean inLoad = tab.inPageLoad();
703        if ((!mActivityPaused && !inLoad) || (mActivityPaused && inLoad)) {
704            CookieSyncManager.getInstance().startSync();
705            WebView w = tab.getWebView();
706            WebViewTimersControl.getInstance().onBrowserActivityResume(w);
707        }
708    }
709
710    /**
711     * Pause all WebView timers using the WebView of the given tab
712     * @param tab
713     * @return true if the timers are paused or tab is null
714     */
715    private boolean pauseWebViewTimers(Tab tab) {
716        if (tab == null) {
717            return true;
718        } else if (!tab.inPageLoad()) {
719            CookieSyncManager.getInstance().stopSync();
720            WebViewTimersControl.getInstance().onBrowserActivityPause(getCurrentWebView());
721            return true;
722        }
723        return false;
724    }
725
726    void onDestroy() {
727        if (mUploadHandler != null && !mUploadHandler.handled()) {
728            mUploadHandler.onResult(Activity.RESULT_CANCELED, null);
729            mUploadHandler = null;
730        }
731        if (mTabControl == null) return;
732        mUi.onDestroy();
733        // Remove the current tab and sub window
734        Tab t = mTabControl.getCurrentTab();
735        if (t != null) {
736            dismissSubWindow(t);
737            removeTab(t);
738        }
739        mActivity.getContentResolver().unregisterContentObserver(mBookmarksObserver);
740        // Destroy all the tabs
741        mTabControl.destroy();
742        WebIconDatabase.getInstance().close();
743        // Stop watching the default geolocation permissions
744        mSystemAllowGeolocationOrigins.stop();
745        mSystemAllowGeolocationOrigins = null;
746    }
747
748    protected boolean isActivityPaused() {
749        return mActivityPaused;
750    }
751
752    protected void onLowMemory() {
753        mTabControl.freeMemory();
754    }
755
756    @Override
757    public boolean shouldShowErrorConsole() {
758        return mShouldShowErrorConsole;
759    }
760
761    protected void setShouldShowErrorConsole(boolean show) {
762        if (show == mShouldShowErrorConsole) {
763            // Nothing to do.
764            return;
765        }
766        mShouldShowErrorConsole = show;
767        Tab t = mTabControl.getCurrentTab();
768        if (t == null) {
769            // There is no current tab so we cannot toggle the error console
770            return;
771        }
772        mUi.setShouldShowErrorConsole(t, show);
773    }
774
775    @Override
776    public void stopLoading() {
777        mLoadStopped = true;
778        Tab tab = mTabControl.getCurrentTab();
779        WebView w = getCurrentTopWebView();
780        w.stopLoading();
781        mUi.onPageStopped(tab);
782    }
783
784    boolean didUserStopLoading() {
785        return mLoadStopped;
786    }
787
788    // WebViewController
789
790    @Override
791    public void onPageStarted(Tab tab, WebView view, Bitmap favicon) {
792
793        // We've started to load a new page. If there was a pending message
794        // to save a screenshot then we will now take the new page and save
795        // an incorrect screenshot. Therefore, remove any pending thumbnail
796        // messages from the queue.
797        mHandler.removeMessages(Controller.UPDATE_BOOKMARK_THUMBNAIL,
798                tab);
799
800        // reset sync timer to avoid sync starts during loading a page
801        CookieSyncManager.getInstance().resetSync();
802
803        if (!mNetworkHandler.isNetworkUp()) {
804            view.setNetworkAvailable(false);
805        }
806
807        // when BrowserActivity just starts, onPageStarted may be called before
808        // onResume as it is triggered from onCreate. Call resumeWebViewTimers
809        // to start the timer. As we won't switch tabs while an activity is in
810        // pause state, we can ensure calling resume and pause in pair.
811        if (mActivityPaused) {
812            resumeWebViewTimers(tab);
813        }
814        mLoadStopped = false;
815        if (!mNetworkHandler.isNetworkUp()) {
816            mNetworkHandler.createAndShowNetworkDialog();
817        }
818        endActionMode();
819
820        mUi.onTabDataChanged(tab);
821
822        String url = tab.getUrl();
823        // update the bookmark database for favicon
824        maybeUpdateFavicon(tab, null, url, favicon);
825
826        Performance.tracePageStart(url);
827
828        // Performance probe
829        if (false) {
830            Performance.onPageStarted();
831        }
832
833    }
834
835    @Override
836    public void onPageFinished(Tab tab) {
837        mUi.onTabDataChanged(tab);
838        if (!tab.isPrivateBrowsingEnabled()
839                && !TextUtils.isEmpty(tab.getUrl())
840                && !tab.isSnapshot()) {
841            // Only update the bookmark screenshot if the user did not
842            // cancel the load early and there is not already
843            // a pending update for the tab.
844            if (tab.inForeground() && !didUserStopLoading()
845                    || !tab.inForeground()) {
846                if (!mHandler.hasMessages(UPDATE_BOOKMARK_THUMBNAIL, tab)) {
847                    mHandler.sendMessageDelayed(mHandler.obtainMessage(
848                            UPDATE_BOOKMARK_THUMBNAIL, 0, 0, tab),
849                            500);
850                }
851            }
852        }
853        // pause the WebView timer and release the wake lock if it is finished
854        // while BrowserActivity is in pause state.
855        if (mActivityPaused && pauseWebViewTimers(tab)) {
856            releaseWakeLock();
857        }
858
859        // Performance probe
860        if (false) {
861            Performance.onPageFinished(tab.getUrl());
862         }
863
864        Performance.tracePageFinished();
865    }
866
867    @Override
868    public void onProgressChanged(Tab tab) {
869        int newProgress = tab.getLoadProgress();
870
871        if (newProgress == 100) {
872            CookieSyncManager.getInstance().sync();
873            // onProgressChanged() may continue to be called after the main
874            // frame has finished loading, as any remaining sub frames continue
875            // to load. We'll only get called once though with newProgress as
876            // 100 when everything is loaded. (onPageFinished is called once
877            // when the main frame completes loading regardless of the state of
878            // any sub frames so calls to onProgressChanges may continue after
879            // onPageFinished has executed)
880            if (mInLoad) {
881                mInLoad = false;
882                updateInLoadMenuItems(mCachedMenu);
883            }
884        } else {
885            if (!mInLoad) {
886                // onPageFinished may have already been called but a subframe is
887                // still loading and updating the progress. Reset mInLoad and
888                // update the menu items.
889                mInLoad = true;
890                updateInLoadMenuItems(mCachedMenu);
891            }
892        }
893        mUi.onProgressChanged(tab);
894    }
895
896    @Override
897    public void onUpdatedLockIcon(Tab tab) {
898        mUi.onTabDataChanged(tab);
899    }
900
901    @Override
902    public void onReceivedTitle(Tab tab, final String title) {
903        mUi.onTabDataChanged(tab);
904        final String pageUrl = tab.getOriginalUrl();
905        if (TextUtils.isEmpty(pageUrl) || pageUrl.length()
906                >= SQLiteDatabase.SQLITE_MAX_LIKE_PATTERN_LENGTH) {
907            return;
908        }
909        // Update the title in the history database if not in private browsing mode
910        if (!tab.isPrivateBrowsingEnabled()) {
911            DataController.getInstance(mActivity).updateHistoryTitle(pageUrl, title);
912        }
913    }
914
915    @Override
916    public void onFavicon(Tab tab, WebView view, Bitmap icon) {
917        mUi.onTabDataChanged(tab);
918        maybeUpdateFavicon(tab, view.getOriginalUrl(), view.getUrl(), icon);
919    }
920
921    @Override
922    public boolean shouldOverrideUrlLoading(Tab tab, WebView view, String url) {
923        return mUrlHandler.shouldOverrideUrlLoading(tab, view, url);
924    }
925
926    @Override
927    public boolean shouldOverrideKeyEvent(KeyEvent event) {
928        if (mMenuIsDown) {
929            // only check shortcut key when MENU is held
930            return mActivity.getWindow().isShortcutKey(event.getKeyCode(),
931                    event);
932        } else {
933            return false;
934        }
935    }
936
937    @Override
938    public void onUnhandledKeyEvent(KeyEvent event) {
939        if (!isActivityPaused()) {
940            if (event.getAction() == KeyEvent.ACTION_DOWN) {
941                mActivity.onKeyDown(event.getKeyCode(), event);
942            } else {
943                mActivity.onKeyUp(event.getKeyCode(), event);
944            }
945        }
946    }
947
948    @Override
949    public void doUpdateVisitedHistory(Tab tab, boolean isReload) {
950        // Don't save anything in private browsing mode
951        if (tab.isPrivateBrowsingEnabled()) return;
952        String url = tab.getOriginalUrl();
953
954        if (TextUtils.isEmpty(url)
955                || url.regionMatches(true, 0, "about:", 0, 6)) {
956            return;
957        }
958        DataController.getInstance(mActivity).updateVisitedHistory(url);
959        if (!mActivityPaused) {
960            // Since we clear the state in onPause, don't backup the current
961            // state if we are already paused
962            mCrashRecoveryHandler.backupState();
963        }
964    }
965
966    @Override
967    public void getVisitedHistory(final ValueCallback<String[]> callback) {
968        AsyncTask<Void, Void, String[]> task =
969                new AsyncTask<Void, Void, String[]>() {
970            @Override
971            public String[] doInBackground(Void... unused) {
972                return Browser.getVisitedHistory(mActivity.getContentResolver());
973            }
974            @Override
975            public void onPostExecute(String[] result) {
976                callback.onReceiveValue(result);
977            }
978        };
979        task.execute();
980    }
981
982    @Override
983    public void onReceivedHttpAuthRequest(Tab tab, WebView view,
984            final HttpAuthHandler handler, final String host,
985            final String realm) {
986        String username = null;
987        String password = null;
988
989        boolean reuseHttpAuthUsernamePassword
990                = handler.useHttpAuthUsernamePassword();
991
992        if (reuseHttpAuthUsernamePassword && view != null) {
993            String[] credentials = view.getHttpAuthUsernamePassword(host, realm);
994            if (credentials != null && credentials.length == 2) {
995                username = credentials[0];
996                password = credentials[1];
997            }
998        }
999
1000        if (username != null && password != null) {
1001            handler.proceed(username, password);
1002        } else {
1003            if (tab.inForeground()) {
1004                mPageDialogsHandler.showHttpAuthentication(tab, handler, host, realm);
1005            } else {
1006                handler.cancel();
1007            }
1008        }
1009    }
1010
1011    @Override
1012    public void onDownloadStart(Tab tab, String url, String userAgent,
1013            String contentDisposition, String mimetype, long contentLength) {
1014        WebView w = tab.getWebView();
1015        DownloadHandler.onDownloadStart(mActivity, url, userAgent,
1016                contentDisposition, mimetype, w.isPrivateBrowsingEnabled());
1017        if (w.copyBackForwardList().getSize() == 0) {
1018            // This Tab was opened for the sole purpose of downloading a
1019            // file. Remove it.
1020            if (tab == mTabControl.getCurrentTab()) {
1021                // In this case, the Tab is still on top.
1022                goBackOnePageOrQuit();
1023            } else {
1024                // In this case, it is not.
1025                closeTab(tab);
1026            }
1027        }
1028    }
1029
1030    @Override
1031    public Bitmap getDefaultVideoPoster() {
1032        return mUi.getDefaultVideoPoster();
1033    }
1034
1035    @Override
1036    public View getVideoLoadingProgressView() {
1037        return mUi.getVideoLoadingProgressView();
1038    }
1039
1040    @Override
1041    public void showSslCertificateOnError(WebView view, SslErrorHandler handler,
1042            SslError error) {
1043        mPageDialogsHandler.showSSLCertificateOnError(view, handler, error);
1044    }
1045
1046    @Override
1047    public void showAutoLogin(Tab tab) {
1048        assert tab.inForeground();
1049        // Update the title bar to show the auto-login request.
1050        mUi.showAutoLogin(tab);
1051    }
1052
1053    @Override
1054    public void hideAutoLogin(Tab tab) {
1055        assert tab.inForeground();
1056        mUi.hideAutoLogin(tab);
1057    }
1058
1059    // helper method
1060
1061    /*
1062     * Update the favorites icon if the private browsing isn't enabled and the
1063     * icon is valid.
1064     */
1065    private void maybeUpdateFavicon(Tab tab, final String originalUrl,
1066            final String url, Bitmap favicon) {
1067        if (favicon == null) {
1068            return;
1069        }
1070        if (!tab.isPrivateBrowsingEnabled()) {
1071            Bookmarks.updateFavicon(mActivity
1072                    .getContentResolver(), originalUrl, url, favicon);
1073        }
1074    }
1075
1076    @Override
1077    public void bookmarkedStatusHasChanged(Tab tab) {
1078        // TODO: Switch to using onTabDataChanged after b/3262950 is fixed
1079        mUi.bookmarkedStatusHasChanged(tab);
1080    }
1081
1082    // end WebViewController
1083
1084    protected void pageUp() {
1085        getCurrentTopWebView().pageUp(false);
1086    }
1087
1088    protected void pageDown() {
1089        getCurrentTopWebView().pageDown(false);
1090    }
1091
1092    // callback from phone title bar
1093    public void editUrl() {
1094        if (mOptionsMenuOpen) mActivity.closeOptionsMenu();
1095        mUi.editUrl(false);
1096    }
1097
1098    public void startVoiceSearch() {
1099        Intent intent = new Intent(RecognizerIntent.ACTION_WEB_SEARCH);
1100        intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL,
1101                RecognizerIntent.LANGUAGE_MODEL_WEB_SEARCH);
1102        intent.putExtra(RecognizerIntent.EXTRA_CALLING_PACKAGE,
1103                mActivity.getComponentName().flattenToString());
1104        intent.putExtra(SEND_APP_ID_EXTRA, false);
1105        intent.putExtra(RecognizerIntent.EXTRA_WEB_SEARCH_ONLY, true);
1106        mActivity.startActivity(intent);
1107    }
1108
1109    @Override
1110    public void activateVoiceSearchMode(String title, List<String> results) {
1111        mUi.showVoiceTitleBar(title, results);
1112    }
1113
1114    public void revertVoiceSearchMode(Tab tab) {
1115        mUi.revertVoiceTitleBar(tab);
1116    }
1117
1118    public boolean supportsVoiceSearch() {
1119        SearchEngine searchEngine = getSettings().getSearchEngine();
1120        return (searchEngine != null && searchEngine.supportsVoiceSearch());
1121    }
1122
1123    public void showCustomView(Tab tab, View view, int requestedOrientation,
1124            WebChromeClient.CustomViewCallback callback) {
1125        if (tab.inForeground()) {
1126            if (mUi.isCustomViewShowing()) {
1127                callback.onCustomViewHidden();
1128                return;
1129            }
1130            mUi.showCustomView(view, requestedOrientation, callback);
1131            // Save the menu state and set it to empty while the custom
1132            // view is showing.
1133            mOldMenuState = mMenuState;
1134            mMenuState = EMPTY_MENU;
1135            mActivity.invalidateOptionsMenu();
1136        }
1137    }
1138
1139    @Override
1140    public void hideCustomView() {
1141        if (mUi.isCustomViewShowing()) {
1142            mUi.onHideCustomView();
1143            // Reset the old menu state.
1144            mMenuState = mOldMenuState;
1145            mOldMenuState = EMPTY_MENU;
1146            mActivity.invalidateOptionsMenu();
1147        }
1148    }
1149
1150    protected void onActivityResult(int requestCode, int resultCode,
1151            Intent intent) {
1152        if (getCurrentTopWebView() == null) return;
1153        switch (requestCode) {
1154            case PREFERENCES_PAGE:
1155                if (resultCode == Activity.RESULT_OK && intent != null) {
1156                    String action = intent.getStringExtra(Intent.EXTRA_TEXT);
1157                    if (PreferenceKeys.PREF_PRIVACY_CLEAR_HISTORY.equals(action)) {
1158                        mTabControl.removeParentChildRelationShips();
1159                    }
1160                }
1161                break;
1162            case FILE_SELECTED:
1163                // Chose a file from the file picker.
1164                if (null == mUploadHandler) break;
1165                mUploadHandler.onResult(resultCode, intent);
1166                break;
1167            case AUTOFILL_SETUP:
1168                // Determine whether a profile was actually set up or not
1169                // and if so, send the message back to the WebTextView to
1170                // fill the form with the new profile.
1171                if (getSettings().getAutoFillProfile() != null) {
1172                    mAutoFillSetupMessage.sendToTarget();
1173                    mAutoFillSetupMessage = null;
1174                }
1175                break;
1176            case COMBO_VIEW:
1177                if (intent == null || resultCode != Activity.RESULT_OK) {
1178                    break;
1179                }
1180                if (Intent.ACTION_VIEW.equals(intent.getAction())) {
1181                    Tab t = getCurrentTab();
1182                    Uri uri = intent.getData();
1183                    loadUrl(t, uri.toString());
1184                } else if (intent.hasExtra(ComboViewActivity.EXTRA_OPEN_ALL)) {
1185                    String[] urls = intent.getStringArrayExtra(
1186                            ComboViewActivity.EXTRA_OPEN_ALL);
1187                    Tab parent = getCurrentTab();
1188                    for (String url : urls) {
1189                        parent = openTab(url, parent,
1190                                !mSettings.openInBackground(), true);
1191                    }
1192                } else if (intent.hasExtra(ComboViewActivity.EXTRA_OPEN_SNAPSHOT)) {
1193                    long id = intent.getLongExtra(
1194                            ComboViewActivity.EXTRA_OPEN_SNAPSHOT, -1);
1195                    if (id >= 0) {
1196                        createNewSnapshotTab(id, true);
1197                    }
1198                }
1199                break;
1200            default:
1201                break;
1202        }
1203        getCurrentTopWebView().requestFocus();
1204    }
1205
1206    /**
1207     * Open the Go page.
1208     * @param startWithHistory If true, open starting on the history tab.
1209     *                         Otherwise, start with the bookmarks tab.
1210     */
1211    @Override
1212    public void bookmarksOrHistoryPicker(boolean startWithHistory) {
1213        if (mTabControl.getCurrentWebView() == null) {
1214            return;
1215        }
1216        // clear action mode
1217        if (isInCustomActionMode()) {
1218            endActionMode();
1219        }
1220        Bundle extras = new Bundle();
1221        // Disable opening in a new window if we have maxed out the windows
1222        extras.putBoolean(BrowserBookmarksPage.EXTRA_DISABLE_WINDOW,
1223                !mTabControl.canCreateNewTab());
1224        mUi.showComboView(startWithHistory
1225                ? ComboViews.History : ComboViews.Bookmarks, extras);
1226    }
1227
1228    // combo view callbacks
1229
1230    /**
1231     * callback from ComboPage when clear history is requested
1232     */
1233    public void onRemoveParentChildRelationships() {
1234        mTabControl.removeParentChildRelationShips();
1235    }
1236
1237    // key handling
1238    protected void onBackKey() {
1239        if (!mUi.onBackKey()) {
1240            WebView subwindow = mTabControl.getCurrentSubWindow();
1241            if (subwindow != null) {
1242                if (subwindow.canGoBack()) {
1243                    subwindow.goBack();
1244                } else {
1245                    dismissSubWindow(mTabControl.getCurrentTab());
1246                }
1247            } else {
1248                goBackOnePageOrQuit();
1249            }
1250        }
1251    }
1252
1253    protected boolean onMenuKey() {
1254        return mUi.onMenuKey();
1255    }
1256
1257    // menu handling and state
1258    // TODO: maybe put into separate handler
1259
1260    protected boolean onCreateOptionsMenu(Menu menu) {
1261        if (mMenuState == EMPTY_MENU) {
1262            return false;
1263        }
1264        MenuInflater inflater = mActivity.getMenuInflater();
1265        inflater.inflate(R.menu.browser, menu);
1266        updateInLoadMenuItems(menu);
1267        // hold on to the menu reference here; it is used by the page callbacks
1268        // to update the menu based on loading state
1269        mCachedMenu = menu;
1270        return true;
1271    }
1272
1273    protected void onCreateContextMenu(ContextMenu menu, View v,
1274            ContextMenuInfo menuInfo) {
1275        if (v instanceof TitleBar) {
1276            return;
1277        }
1278        if (!(v instanceof WebView)) {
1279            return;
1280        }
1281        final WebView webview = (WebView) v;
1282        WebView.HitTestResult result = webview.getHitTestResult();
1283        if (result == null) {
1284            return;
1285        }
1286
1287        int type = result.getType();
1288        if (type == WebView.HitTestResult.UNKNOWN_TYPE) {
1289            Log.w(LOGTAG,
1290                    "We should not show context menu when nothing is touched");
1291            return;
1292        }
1293        if (type == WebView.HitTestResult.EDIT_TEXT_TYPE) {
1294            // let TextView handles context menu
1295            return;
1296        }
1297
1298        // Note, http://b/issue?id=1106666 is requesting that
1299        // an inflated menu can be used again. This is not available
1300        // yet, so inflate each time (yuk!)
1301        MenuInflater inflater = mActivity.getMenuInflater();
1302        inflater.inflate(R.menu.browsercontext, menu);
1303
1304        // Show the correct menu group
1305        final String extra = result.getExtra();
1306        menu.setGroupVisible(R.id.PHONE_MENU,
1307                type == WebView.HitTestResult.PHONE_TYPE);
1308        menu.setGroupVisible(R.id.EMAIL_MENU,
1309                type == WebView.HitTestResult.EMAIL_TYPE);
1310        menu.setGroupVisible(R.id.GEO_MENU,
1311                type == WebView.HitTestResult.GEO_TYPE);
1312        menu.setGroupVisible(R.id.IMAGE_MENU,
1313                type == WebView.HitTestResult.IMAGE_TYPE
1314                || type == WebView.HitTestResult.SRC_IMAGE_ANCHOR_TYPE);
1315        menu.setGroupVisible(R.id.ANCHOR_MENU,
1316                type == WebView.HitTestResult.SRC_ANCHOR_TYPE
1317                || type == WebView.HitTestResult.SRC_IMAGE_ANCHOR_TYPE);
1318        boolean hitText = type == WebView.HitTestResult.SRC_ANCHOR_TYPE
1319                || type == WebView.HitTestResult.PHONE_TYPE
1320                || type == WebView.HitTestResult.EMAIL_TYPE
1321                || type == WebView.HitTestResult.GEO_TYPE;
1322        menu.setGroupVisible(R.id.SELECT_TEXT_MENU, hitText);
1323        if (hitText) {
1324            menu.findItem(R.id.select_text_menu_id)
1325                    .setOnMenuItemClickListener(new SelectText(webview));
1326        }
1327        // Setup custom handling depending on the type
1328        switch (type) {
1329            case WebView.HitTestResult.PHONE_TYPE:
1330                menu.setHeaderTitle(Uri.decode(extra));
1331                menu.findItem(R.id.dial_context_menu_id).setIntent(
1332                        new Intent(Intent.ACTION_VIEW, Uri
1333                                .parse(WebView.SCHEME_TEL + extra)));
1334                Intent addIntent = new Intent(Intent.ACTION_INSERT_OR_EDIT);
1335                addIntent.putExtra(Insert.PHONE, Uri.decode(extra));
1336                addIntent.setType(ContactsContract.Contacts.CONTENT_ITEM_TYPE);
1337                menu.findItem(R.id.add_contact_context_menu_id).setIntent(
1338                        addIntent);
1339                menu.findItem(R.id.copy_phone_context_menu_id)
1340                        .setOnMenuItemClickListener(
1341                        new Copy(extra));
1342                break;
1343
1344            case WebView.HitTestResult.EMAIL_TYPE:
1345                menu.setHeaderTitle(extra);
1346                menu.findItem(R.id.email_context_menu_id).setIntent(
1347                        new Intent(Intent.ACTION_VIEW, Uri
1348                                .parse(WebView.SCHEME_MAILTO + extra)));
1349                menu.findItem(R.id.copy_mail_context_menu_id)
1350                        .setOnMenuItemClickListener(
1351                        new Copy(extra));
1352                break;
1353
1354            case WebView.HitTestResult.GEO_TYPE:
1355                menu.setHeaderTitle(extra);
1356                menu.findItem(R.id.map_context_menu_id).setIntent(
1357                        new Intent(Intent.ACTION_VIEW, Uri
1358                                .parse(WebView.SCHEME_GEO
1359                                        + URLEncoder.encode(extra))));
1360                menu.findItem(R.id.copy_geo_context_menu_id)
1361                        .setOnMenuItemClickListener(
1362                        new Copy(extra));
1363                break;
1364
1365            case WebView.HitTestResult.SRC_ANCHOR_TYPE:
1366            case WebView.HitTestResult.SRC_IMAGE_ANCHOR_TYPE:
1367                menu.setHeaderTitle(extra);
1368                // decide whether to show the open link in new tab option
1369                boolean showNewTab = mTabControl.canCreateNewTab();
1370                MenuItem newTabItem
1371                        = menu.findItem(R.id.open_newtab_context_menu_id);
1372                newTabItem.setTitle(getSettings().openInBackground()
1373                        ? R.string.contextmenu_openlink_newwindow_background
1374                        : R.string.contextmenu_openlink_newwindow);
1375                newTabItem.setVisible(showNewTab);
1376                if (showNewTab) {
1377                    if (WebView.HitTestResult.SRC_IMAGE_ANCHOR_TYPE == type) {
1378                        newTabItem.setOnMenuItemClickListener(
1379                                new MenuItem.OnMenuItemClickListener() {
1380                                    @Override
1381                                    public boolean onMenuItemClick(MenuItem item) {
1382                                        final HashMap<String, WebView> hrefMap =
1383                                                new HashMap<String, WebView>();
1384                                        hrefMap.put("webview", webview);
1385                                        final Message msg = mHandler.obtainMessage(
1386                                                FOCUS_NODE_HREF,
1387                                                R.id.open_newtab_context_menu_id,
1388                                                0, hrefMap);
1389                                        webview.requestFocusNodeHref(msg);
1390                                        return true;
1391                                    }
1392                                });
1393                    } else {
1394                        newTabItem.setOnMenuItemClickListener(
1395                                new MenuItem.OnMenuItemClickListener() {
1396                                    @Override
1397                                    public boolean onMenuItemClick(MenuItem item) {
1398                                        final Tab parent = mTabControl.getCurrentTab();
1399                                        openTab(extra, parent,
1400                                                !mSettings.openInBackground(),
1401                                                true);
1402                                        return true;
1403                                    }
1404                                });
1405                    }
1406                }
1407                if (type == WebView.HitTestResult.SRC_ANCHOR_TYPE) {
1408                    break;
1409                }
1410                // otherwise fall through to handle image part
1411            case WebView.HitTestResult.IMAGE_TYPE:
1412                if (type == WebView.HitTestResult.IMAGE_TYPE) {
1413                    menu.setHeaderTitle(extra);
1414                }
1415                menu.findItem(R.id.view_image_context_menu_id).setIntent(
1416                        new Intent(Intent.ACTION_VIEW, Uri.parse(extra)));
1417                menu.findItem(R.id.download_context_menu_id).
1418                        setOnMenuItemClickListener(
1419                                new Download(mActivity, extra, webview.isPrivateBrowsingEnabled()));
1420                menu.findItem(R.id.set_wallpaper_context_menu_id).
1421                        setOnMenuItemClickListener(new WallpaperHandler(mActivity,
1422                                extra));
1423                break;
1424
1425            default:
1426                Log.w(LOGTAG, "We should not get here.");
1427                break;
1428        }
1429        //update the ui
1430        mUi.onContextMenuCreated(menu);
1431    }
1432
1433    /**
1434     * As the menu can be open when loading state changes
1435     * we must manually update the state of the stop/reload menu
1436     * item
1437     */
1438    private void updateInLoadMenuItems(Menu menu) {
1439        if (menu == null) {
1440            return;
1441        }
1442        MenuItem dest = menu.findItem(R.id.stop_reload_menu_id);
1443        MenuItem src = mInLoad ?
1444                menu.findItem(R.id.stop_menu_id):
1445                menu.findItem(R.id.reload_menu_id);
1446        if (src != null) {
1447            dest.setIcon(src.getIcon());
1448            dest.setTitle(src.getTitle());
1449        }
1450    }
1451
1452    boolean onPrepareOptionsMenu(Menu menu) {
1453        // Note: setVisible will decide whether an item is visible; while
1454        // setEnabled() will decide whether an item is enabled, which also means
1455        // whether the matching shortcut key will function.
1456        switch (mMenuState) {
1457            case EMPTY_MENU:
1458                if (mCurrentMenuState != mMenuState) {
1459                    menu.setGroupVisible(R.id.MAIN_MENU, false);
1460                    menu.setGroupEnabled(R.id.MAIN_MENU, false);
1461                    menu.setGroupEnabled(R.id.MAIN_SHORTCUT_MENU, false);
1462                }
1463                break;
1464            default:
1465                if (mCurrentMenuState != mMenuState) {
1466                    menu.setGroupVisible(R.id.MAIN_MENU, true);
1467                    menu.setGroupEnabled(R.id.MAIN_MENU, true);
1468                    menu.setGroupEnabled(R.id.MAIN_SHORTCUT_MENU, true);
1469                }
1470                updateMenuState(getCurrentTab(), menu);
1471                break;
1472        }
1473        mCurrentMenuState = mMenuState;
1474        return mUi.onPrepareOptionsMenu(menu);
1475    }
1476
1477    @Override
1478    public void updateMenuState(Tab tab, Menu menu) {
1479        boolean canGoBack = false;
1480        boolean canGoForward = false;
1481        boolean isHome = false;
1482        if (tab != null) {
1483            canGoBack = tab.canGoBack();
1484            canGoForward = tab.canGoForward();
1485            isHome = mSettings.getHomePage().equals(tab.getUrl());
1486        }
1487        final MenuItem back = menu.findItem(R.id.back_menu_id);
1488        back.setEnabled(canGoBack);
1489
1490        final MenuItem home = menu.findItem(R.id.homepage_menu_id);
1491        home.setEnabled(!isHome);
1492
1493        final MenuItem forward = menu.findItem(R.id.forward_menu_id);
1494        forward.setEnabled(canGoForward);
1495
1496        final MenuItem source = menu.findItem(mInLoad ? R.id.stop_menu_id : R.id.reload_menu_id);
1497        final MenuItem dest = menu.findItem(R.id.stop_reload_menu_id);
1498        if (source != null && dest != null) {
1499            dest.setTitle(source.getTitle());
1500            dest.setIcon(source.getIcon());
1501        }
1502
1503        // decide whether to show the share link option
1504        PackageManager pm = mActivity.getPackageManager();
1505        Intent send = new Intent(Intent.ACTION_SEND);
1506        send.setType("text/plain");
1507        ResolveInfo ri = pm.resolveActivity(send,
1508                PackageManager.MATCH_DEFAULT_ONLY);
1509        menu.findItem(R.id.share_page_menu_id).setVisible(ri != null);
1510
1511        boolean isNavDump = mSettings.enableNavDump();
1512        final MenuItem nav = menu.findItem(R.id.dump_nav_menu_id);
1513        nav.setVisible(isNavDump);
1514        nav.setEnabled(isNavDump);
1515
1516        boolean showDebugSettings = mSettings.isDebugEnabled();
1517        final MenuItem counter = menu.findItem(R.id.dump_counters_menu_id);
1518        counter.setVisible(showDebugSettings);
1519        counter.setEnabled(showDebugSettings);
1520
1521        MenuItem saveSnapshot = menu.findItem(R.id.save_snapshot_menu_id);
1522        saveSnapshot.setVisible(tab != null && !tab.isSnapshot());
1523        mUi.updateMenuState(tab, menu);
1524    }
1525
1526    public boolean onOptionsItemSelected(MenuItem item) {
1527        if (null == getCurrentTopWebView()) {
1528            return false;
1529        }
1530        if (mMenuIsDown) {
1531            // The shortcut action consumes the MENU. Even if it is still down,
1532            // it won't trigger the next shortcut action. In the case of the
1533            // shortcut action triggering a new activity, like Bookmarks, we
1534            // won't get onKeyUp for MENU. So it is important to reset it here.
1535            mMenuIsDown = false;
1536        }
1537        if (mUi.onOptionsItemSelected(item)) {
1538            // ui callback handled it
1539            return true;
1540        }
1541        switch (item.getItemId()) {
1542            // -- Main menu
1543            case R.id.new_tab_menu_id:
1544                openTabToHomePage();
1545                break;
1546
1547            case R.id.incognito_menu_id:
1548                openIncognitoTab();
1549                break;
1550
1551            case R.id.goto_menu_id:
1552                editUrl();
1553                break;
1554
1555            case R.id.bookmarks_menu_id:
1556                bookmarksOrHistoryPicker(false);
1557                break;
1558
1559            case R.id.add_bookmark_menu_id:
1560                mActivity.startActivity(createBookmarkCurrentPageIntent(false));
1561                break;
1562
1563            case R.id.stop_reload_menu_id:
1564                if (mInLoad) {
1565                    stopLoading();
1566                } else {
1567                    getCurrentTopWebView().reload();
1568                }
1569                break;
1570
1571            case R.id.back_menu_id:
1572                getCurrentTab().goBack();
1573                break;
1574
1575            case R.id.forward_menu_id:
1576                getCurrentTab().goForward();
1577                break;
1578
1579            case R.id.close_menu_id:
1580                // Close the subwindow if it exists.
1581                if (mTabControl.getCurrentSubWindow() != null) {
1582                    dismissSubWindow(mTabControl.getCurrentTab());
1583                    break;
1584                }
1585                closeCurrentTab();
1586                break;
1587
1588            case R.id.homepage_menu_id:
1589                Tab current = mTabControl.getCurrentTab();
1590                loadUrl(current, mSettings.getHomePage());
1591                break;
1592
1593            case R.id.preferences_menu_id:
1594                Intent intent = new Intent(mActivity, BrowserPreferencesPage.class);
1595                intent.putExtra(BrowserPreferencesPage.CURRENT_PAGE,
1596                        getCurrentTopWebView().getUrl());
1597                mActivity.startActivityForResult(intent, PREFERENCES_PAGE);
1598                break;
1599
1600            case R.id.find_menu_id:
1601                getCurrentTopWebView().showFindDialog(null, true);
1602                break;
1603
1604            case R.id.save_snapshot_menu_id:
1605                final Tab source = getTabControl().getCurrentTab();
1606                if (source == null) break;
1607                final ContentResolver cr = mActivity.getContentResolver();
1608                final ContentValues values = source.createSnapshotValues();
1609                if (values != null) {
1610                    new AsyncTask<Tab, Void, Long>() {
1611
1612                        @Override
1613                        protected Long doInBackground(Tab... params) {
1614                            Uri result = cr.insert(Snapshots.CONTENT_URI, values);
1615                            long id = ContentUris.parseId(result);
1616                            return id;
1617                        }
1618
1619                        @Override
1620                        protected void onPostExecute(Long id) {
1621                            Bundle b = new Bundle();
1622                            b.putLong(BrowserSnapshotPage.EXTRA_ANIMATE_ID, id);
1623                            mUi.showComboView(ComboViews.Snapshots, b);
1624                        };
1625                    }.execute(source);
1626                } else {
1627                    Toast.makeText(mActivity, R.string.snapshot_failed,
1628                            Toast.LENGTH_SHORT).show();
1629                }
1630                break;
1631
1632            case R.id.page_info_menu_id:
1633                mPageDialogsHandler.showPageInfo(mTabControl.getCurrentTab(), false, null);
1634                break;
1635
1636            case R.id.classic_history_menu_id:
1637                bookmarksOrHistoryPicker(true);
1638                break;
1639
1640            case R.id.share_page_menu_id:
1641                Tab currentTab = mTabControl.getCurrentTab();
1642                if (null == currentTab) {
1643                    return false;
1644                }
1645                shareCurrentPage(currentTab);
1646                break;
1647
1648            case R.id.dump_nav_menu_id:
1649                getCurrentTopWebView().debugDump();
1650                break;
1651
1652            case R.id.dump_counters_menu_id:
1653                getCurrentTopWebView().dumpV8Counters();
1654                break;
1655
1656            case R.id.zoom_in_menu_id:
1657                getCurrentTopWebView().zoomIn();
1658                break;
1659
1660            case R.id.zoom_out_menu_id:
1661                getCurrentTopWebView().zoomOut();
1662                break;
1663
1664            case R.id.view_downloads_menu_id:
1665                viewDownloads();
1666                break;
1667
1668            case R.id.window_one_menu_id:
1669            case R.id.window_two_menu_id:
1670            case R.id.window_three_menu_id:
1671            case R.id.window_four_menu_id:
1672            case R.id.window_five_menu_id:
1673            case R.id.window_six_menu_id:
1674            case R.id.window_seven_menu_id:
1675            case R.id.window_eight_menu_id:
1676                {
1677                    int menuid = item.getItemId();
1678                    for (int id = 0; id < WINDOW_SHORTCUT_ID_ARRAY.length; id++) {
1679                        if (WINDOW_SHORTCUT_ID_ARRAY[id] == menuid) {
1680                            Tab desiredTab = mTabControl.getTab(id);
1681                            if (desiredTab != null &&
1682                                    desiredTab != mTabControl.getCurrentTab()) {
1683                                switchToTab(desiredTab);
1684                            }
1685                            break;
1686                        }
1687                    }
1688                }
1689                break;
1690
1691            default:
1692                return false;
1693        }
1694        return true;
1695    }
1696
1697    public boolean onContextItemSelected(MenuItem item) {
1698        // Let the History and Bookmark fragments handle menus they created.
1699        if (item.getGroupId() == R.id.CONTEXT_MENU) {
1700            return false;
1701        }
1702
1703        int id = item.getItemId();
1704        boolean result = true;
1705        switch (id) {
1706            // -- Browser context menu
1707            case R.id.open_context_menu_id:
1708            case R.id.save_link_context_menu_id:
1709            case R.id.copy_link_context_menu_id:
1710                final WebView webView = getCurrentTopWebView();
1711                if (null == webView) {
1712                    result = false;
1713                    break;
1714                }
1715                final HashMap<String, WebView> hrefMap =
1716                        new HashMap<String, WebView>();
1717                hrefMap.put("webview", webView);
1718                final Message msg = mHandler.obtainMessage(
1719                        FOCUS_NODE_HREF, id, 0, hrefMap);
1720                webView.requestFocusNodeHref(msg);
1721                break;
1722
1723            default:
1724                // For other context menus
1725                result = onOptionsItemSelected(item);
1726        }
1727        return result;
1728    }
1729
1730    /**
1731     * support programmatically opening the context menu
1732     */
1733    public void openContextMenu(View view) {
1734        mActivity.openContextMenu(view);
1735    }
1736
1737    /**
1738     * programmatically open the options menu
1739     */
1740    public void openOptionsMenu() {
1741        mActivity.openOptionsMenu();
1742    }
1743
1744    public boolean onMenuOpened(int featureId, Menu menu) {
1745        if (mOptionsMenuOpen) {
1746            if (mConfigChanged) {
1747                // We do not need to make any changes to the state of the
1748                // title bar, since the only thing that happened was a
1749                // change in orientation
1750                mConfigChanged = false;
1751            } else {
1752                if (!mExtendedMenuOpen) {
1753                    mExtendedMenuOpen = true;
1754                    mUi.onExtendedMenuOpened();
1755                } else {
1756                    // Switching the menu back to icon view, so show the
1757                    // title bar once again.
1758                    mExtendedMenuOpen = false;
1759                    mUi.onExtendedMenuClosed(mInLoad);
1760                }
1761            }
1762        } else {
1763            // The options menu is closed, so open it, and show the title
1764            mOptionsMenuOpen = true;
1765            mConfigChanged = false;
1766            mExtendedMenuOpen = false;
1767            mUi.onOptionsMenuOpened();
1768        }
1769        return true;
1770    }
1771
1772    public void onOptionsMenuClosed(Menu menu) {
1773        mOptionsMenuOpen = false;
1774        mUi.onOptionsMenuClosed(mInLoad);
1775    }
1776
1777    public void onContextMenuClosed(Menu menu) {
1778        mUi.onContextMenuClosed(menu, mInLoad);
1779    }
1780
1781    // Helper method for getting the top window.
1782    @Override
1783    public WebView getCurrentTopWebView() {
1784        return mTabControl.getCurrentTopWebView();
1785    }
1786
1787    @Override
1788    public WebView getCurrentWebView() {
1789        return mTabControl.getCurrentWebView();
1790    }
1791
1792    /*
1793     * This method is called as a result of the user selecting the options
1794     * menu to see the download window. It shows the download window on top of
1795     * the current window.
1796     */
1797    void viewDownloads() {
1798        Intent intent = new Intent(DownloadManager.ACTION_VIEW_DOWNLOADS);
1799        mActivity.startActivity(intent);
1800    }
1801
1802    int getActionModeHeight() {
1803        TypedArray actionBarSizeTypedArray = mActivity.obtainStyledAttributes(
1804                    new int[] { android.R.attr.actionBarSize });
1805        int size = (int) actionBarSizeTypedArray.getDimension(0, 0f);
1806        actionBarSizeTypedArray.recycle();
1807        return size;
1808    }
1809
1810    // action mode
1811
1812    void onActionModeStarted(ActionMode mode) {
1813        mUi.onActionModeStarted(mode);
1814        mActionMode = mode;
1815        if (mSimulateActionBarOverlayMode && !mUi.isEditingUrl()) {
1816            WebView web = getCurrentWebView();
1817            // Simulate overlay mode by scrolling the webview the amount it will be
1818            // pushed down. Actual overlay mode doesn't work for us as otherwise
1819            // the CAB will, well, overlay the content, which breaks things like
1820            // find on page.
1821            int scrollBy = getActionModeHeight();
1822            web.scrollBy(0, scrollBy);
1823        }
1824    }
1825
1826    /*
1827     * True if a custom ActionMode (i.e. find or select) is in use.
1828     */
1829    @Override
1830    public boolean isInCustomActionMode() {
1831        return mActionMode != null;
1832    }
1833
1834    /*
1835     * End the current ActionMode.
1836     */
1837    @Override
1838    public void endActionMode() {
1839        if (mActionMode != null) {
1840            mActionMode.finish();
1841        }
1842    }
1843
1844    /*
1845     * Called by find and select when they are finished.  Replace title bars
1846     * as necessary.
1847     */
1848    public void onActionModeFinished(ActionMode mode) {
1849        if (!isInCustomActionMode()) return;
1850        mUi.onActionModeFinished(mInLoad);
1851        mActionMode = null;
1852        if (mSimulateActionBarOverlayMode) {
1853            WebView web = getCurrentWebView();
1854            int scrollBy = getActionModeHeight();
1855            web.scrollBy(0, -scrollBy);
1856        }
1857    }
1858
1859    boolean isInLoad() {
1860        return mInLoad;
1861    }
1862
1863    // bookmark handling
1864
1865    /**
1866     * add the current page as a bookmark to the given folder id
1867     * @param folderId use -1 for the default folder
1868     * @param editExisting If true, check to see whether the site is already
1869     *          bookmarked, and if it is, edit that bookmark.  If false, and
1870     *          the site is already bookmarked, do not attempt to edit the
1871     *          existing bookmark.
1872     */
1873    @Override
1874    public Intent createBookmarkCurrentPageIntent(boolean editExisting) {
1875        Intent i = new Intent(mActivity,
1876                AddBookmarkPage.class);
1877        WebView w = getCurrentTopWebView();
1878        i.putExtra(BrowserContract.Bookmarks.URL, w.getUrl());
1879        i.putExtra(BrowserContract.Bookmarks.TITLE, w.getTitle());
1880        String touchIconUrl = w.getTouchIconUrl();
1881        if (touchIconUrl != null) {
1882            i.putExtra(AddBookmarkPage.TOUCH_ICON_URL, touchIconUrl);
1883            WebSettings settings = w.getSettings();
1884            if (settings != null) {
1885                i.putExtra(AddBookmarkPage.USER_AGENT,
1886                        settings.getUserAgentString());
1887            }
1888        }
1889        i.putExtra(BrowserContract.Bookmarks.THUMBNAIL,
1890                createScreenshot(w, getDesiredThumbnailWidth(mActivity),
1891                getDesiredThumbnailHeight(mActivity)));
1892        i.putExtra(BrowserContract.Bookmarks.FAVICON, w.getFavicon());
1893        if (editExisting) {
1894            i.putExtra(AddBookmarkPage.CHECK_FOR_DUPE, true);
1895        }
1896        // Put the dialog at the upper right of the screen, covering the
1897        // star on the title bar.
1898        i.putExtra("gravity", Gravity.RIGHT | Gravity.TOP);
1899        return i;
1900    }
1901
1902    // file chooser
1903    public void openFileChooser(ValueCallback<Uri> uploadMsg, String acceptType) {
1904        mUploadHandler = new UploadHandler(this);
1905        mUploadHandler.openFileChooser(uploadMsg, acceptType);
1906    }
1907
1908    // thumbnails
1909
1910    /**
1911     * Return the desired width for thumbnail screenshots, which are stored in
1912     * the database, and used on the bookmarks screen.
1913     * @param context Context for finding out the density of the screen.
1914     * @return desired width for thumbnail screenshot.
1915     */
1916    static int getDesiredThumbnailWidth(Context context) {
1917        return context.getResources().getDimensionPixelOffset(
1918                R.dimen.bookmarkThumbnailWidth);
1919    }
1920
1921    /**
1922     * Return the desired height for thumbnail screenshots, which are stored in
1923     * the database, and used on the bookmarks screen.
1924     * @param context Context for finding out the density of the screen.
1925     * @return desired height for thumbnail screenshot.
1926     */
1927    static int getDesiredThumbnailHeight(Context context) {
1928        return context.getResources().getDimensionPixelOffset(
1929                R.dimen.bookmarkThumbnailHeight);
1930    }
1931
1932    static Bitmap createScreenshot(WebView view, int width, int height) {
1933        // We render to a bitmap 2x the desired size so that we can then
1934        // re-scale it with filtering since canvas.scale doesn't filter
1935        // This helps reduce aliasing at the cost of being slightly blurry
1936        final int filter_scale = 2;
1937        Picture thumbnail = view.capturePicture();
1938        if (thumbnail == null) {
1939            return null;
1940        }
1941        width *= filter_scale;
1942        height *= filter_scale;
1943        Bitmap bm = Bitmap.createBitmap(width, height, Bitmap.Config.RGB_565);
1944        Canvas canvas = new Canvas(bm);
1945        // May need to tweak these values to determine what is the
1946        // best scale factor
1947        int thumbnailWidth = thumbnail.getWidth();
1948        int thumbnailHeight = thumbnail.getHeight();
1949        float scaleFactor = 1.0f;
1950        if (thumbnailWidth > 0 && thumbnailHeight > 0) {
1951            scaleFactor = (float) width / (float)thumbnailWidth;
1952        } else {
1953            return null;
1954        }
1955
1956        float scaleFactorY = (float) height / (float)thumbnailHeight;
1957        if (scaleFactorY > scaleFactor) {
1958            // The picture is narrower than the requested AR
1959            // Center the thumnail and crop the sides
1960            scaleFactor = scaleFactorY;
1961            float wx = (thumbnailWidth * scaleFactor) - width;
1962            canvas.translate((int) -(wx / 2), 0);
1963        }
1964
1965        canvas.scale(scaleFactor, scaleFactor);
1966
1967        thumbnail.draw(canvas);
1968        Bitmap ret = Bitmap.createScaledBitmap(bm, width / filter_scale,
1969                height / filter_scale, true);
1970        canvas.setBitmap(null);
1971        bm.recycle();
1972        return ret;
1973    }
1974
1975    private void updateScreenshot(Tab tab) {
1976        // If this is a bookmarked site, add a screenshot to the database.
1977        // FIXME: Would like to make sure there is actually something to
1978        // draw, but the API for that (WebViewCore.pictureReady()) is not
1979        // currently accessible here.
1980
1981        WebView view = tab.getWebView();
1982        if (view == null) {
1983            // Tab was destroyed
1984            return;
1985        }
1986        final String url = tab.getUrl();
1987        final String originalUrl = view.getOriginalUrl();
1988
1989        if (TextUtils.isEmpty(url)) {
1990            return;
1991        }
1992
1993        // Only update thumbnails for web urls (http(s)://), not for
1994        // about:, javascript:, data:, etc...
1995        // Unless it is a bookmarked site, then always update
1996        if (!Patterns.WEB_URL.matcher(url).matches() && !tab.isBookmarkedSite()) {
1997            return;
1998        }
1999
2000        final Bitmap bm = createScreenshot(view, getDesiredThumbnailWidth(mActivity),
2001                getDesiredThumbnailHeight(mActivity));
2002        if (bm == null) {
2003            return;
2004        }
2005
2006        final ContentResolver cr = mActivity.getContentResolver();
2007        new AsyncTask<Void, Void, Void>() {
2008            @Override
2009            protected Void doInBackground(Void... unused) {
2010                Cursor cursor = null;
2011                try {
2012                    // TODO: Clean this up
2013                    cursor = Bookmarks.queryCombinedForUrl(cr, originalUrl, url);
2014                    if (cursor != null && cursor.moveToFirst()) {
2015                        final ByteArrayOutputStream os =
2016                                new ByteArrayOutputStream();
2017                        bm.compress(Bitmap.CompressFormat.PNG, 100, os);
2018
2019                        ContentValues values = new ContentValues();
2020                        values.put(Images.THUMBNAIL, os.toByteArray());
2021
2022                        do {
2023                            values.put(Images.URL, cursor.getString(0));
2024                            cr.update(Images.CONTENT_URI, values, null, null);
2025                        } while (cursor.moveToNext());
2026                    }
2027                } catch (IllegalStateException e) {
2028                    // Ignore
2029                } finally {
2030                    if (cursor != null) cursor.close();
2031                }
2032                return null;
2033            }
2034        }.execute();
2035    }
2036
2037    private class Copy implements OnMenuItemClickListener {
2038        private CharSequence mText;
2039
2040        public boolean onMenuItemClick(MenuItem item) {
2041            copy(mText);
2042            return true;
2043        }
2044
2045        public Copy(CharSequence toCopy) {
2046            mText = toCopy;
2047        }
2048    }
2049
2050    private static class Download implements OnMenuItemClickListener {
2051        private Activity mActivity;
2052        private String mText;
2053        private boolean mPrivateBrowsing;
2054
2055        public boolean onMenuItemClick(MenuItem item) {
2056            DownloadHandler.onDownloadStartNoStream(mActivity, mText, null,
2057                    null, null, mPrivateBrowsing);
2058            return true;
2059        }
2060
2061        public Download(Activity activity, String toDownload, boolean privateBrowsing) {
2062            mActivity = activity;
2063            mText = toDownload;
2064            mPrivateBrowsing = privateBrowsing;
2065        }
2066    }
2067
2068    private static class SelectText implements OnMenuItemClickListener {
2069        private WebView mWebView;
2070
2071        public boolean onMenuItemClick(MenuItem item) {
2072            if (mWebView != null) {
2073                return mWebView.selectText();
2074            }
2075            return false;
2076        }
2077
2078        public SelectText(WebView webView) {
2079            mWebView = webView;
2080        }
2081
2082    }
2083
2084    /********************** TODO: UI stuff *****************************/
2085
2086    // these methods have been copied, they still need to be cleaned up
2087
2088    /****************** tabs ***************************************************/
2089
2090    // basic tab interactions:
2091
2092    // it is assumed that tabcontrol already knows about the tab
2093    protected void addTab(Tab tab) {
2094        mUi.addTab(tab);
2095    }
2096
2097    protected void removeTab(Tab tab) {
2098        mUi.removeTab(tab);
2099        mTabControl.removeTab(tab);
2100        mCrashRecoveryHandler.backupState();
2101    }
2102
2103    @Override
2104    public void setActiveTab(Tab tab) {
2105        // monkey protection against delayed start
2106        if (tab != null) {
2107            mTabControl.setCurrentTab(tab);
2108            // the tab is guaranteed to have a webview after setCurrentTab
2109            mUi.setActiveTab(tab);
2110        }
2111    }
2112
2113    protected void closeEmptyChildTab() {
2114        Tab current = mTabControl.getCurrentTab();
2115        if (current != null
2116                && current.getWebView().copyBackForwardList().getSize() == 0) {
2117            Tab parent = current.getParent();
2118            if (parent != null) {
2119                switchToTab(parent);
2120                closeTab(current);
2121            }
2122        }
2123    }
2124
2125    protected void reuseTab(Tab appTab, UrlData urlData) {
2126        // Dismiss the subwindow if applicable.
2127        dismissSubWindow(appTab);
2128        // Since we might kill the WebView, remove it from the
2129        // content view first.
2130        mUi.detachTab(appTab);
2131        // Recreate the main WebView after destroying the old one.
2132        mTabControl.recreateWebView(appTab);
2133        // TODO: analyze why the remove and add are necessary
2134        mUi.attachTab(appTab);
2135        if (mTabControl.getCurrentTab() != appTab) {
2136            switchToTab(appTab);
2137            loadUrlDataIn(appTab, urlData);
2138        } else {
2139            // If the tab was the current tab, we have to attach
2140            // it to the view system again.
2141            setActiveTab(appTab);
2142            loadUrlDataIn(appTab, urlData);
2143        }
2144    }
2145
2146    // Remove the sub window if it exists. Also called by TabControl when the
2147    // user clicks the 'X' to dismiss a sub window.
2148    public void dismissSubWindow(Tab tab) {
2149        removeSubWindow(tab);
2150        // dismiss the subwindow. This will destroy the WebView.
2151        tab.dismissSubWindow();
2152        getCurrentTopWebView().requestFocus();
2153    }
2154
2155    @Override
2156    public void removeSubWindow(Tab t) {
2157        if (t.getSubWebView() != null) {
2158            mUi.removeSubWindow(t.getSubViewContainer());
2159        }
2160    }
2161
2162    @Override
2163    public void attachSubWindow(Tab tab) {
2164        if (tab.getSubWebView() != null) {
2165            mUi.attachSubWindow(tab.getSubViewContainer());
2166            getCurrentTopWebView().requestFocus();
2167        }
2168    }
2169
2170    private Tab showPreloadedTab(final UrlData urlData) {
2171        if (!urlData.isPreloaded()) {
2172            return null;
2173        }
2174        final PreloadedTabControl tabControl = urlData.getPreloadedTab();
2175        final String sbQuery = urlData.getSearchBoxQueryToSubmit();
2176        if (sbQuery != null) {
2177            if (!tabControl.searchBoxSubmit(sbQuery, urlData.mUrl, urlData.mHeaders)) {
2178                // Could not submit query. Fallback to regular tab creation
2179                tabControl.destroy();
2180                return null;
2181            }
2182        }
2183        // check tab count and make room for new tab
2184        if (!mTabControl.canCreateNewTab()) {
2185            Tab leastUsed = mTabControl.getLeastUsedTab(getCurrentTab());
2186            if (leastUsed != null) {
2187                closeTab(leastUsed);
2188            }
2189        }
2190        Tab t = tabControl.getTab();
2191        mTabControl.addPreloadedTab(t);
2192        addTab(t);
2193        setActiveTab(t);
2194        return t;
2195    }
2196
2197    // open a non inconito tab with the given url data
2198    // and set as active tab
2199    public Tab openTab(UrlData urlData) {
2200        Tab tab = showPreloadedTab(urlData);
2201        if (tab == null) {
2202            tab = createNewTab(false, true, true);
2203            if ((tab != null) && !urlData.isEmpty()) {
2204                loadUrlDataIn(tab, urlData);
2205            }
2206        }
2207        return tab;
2208    }
2209
2210    @Override
2211    public Tab openTabToHomePage() {
2212        return openTab(mSettings.getHomePage(), false, true, false);
2213    }
2214
2215    @Override
2216    public Tab openIncognitoTab() {
2217        return openTab(INCOGNITO_URI, true, true, false);
2218    }
2219
2220    @Override
2221    public Tab openTab(String url, boolean incognito, boolean setActive,
2222            boolean useCurrent) {
2223        return openTab(url, incognito, setActive, useCurrent, null);
2224    }
2225
2226    @Override
2227    public Tab openTab(String url, Tab parent, boolean setActive,
2228            boolean useCurrent) {
2229        return openTab(url, (parent != null) && parent.isPrivateBrowsingEnabled(),
2230                setActive, useCurrent, parent);
2231    }
2232
2233    public Tab openTab(String url, boolean incognito, boolean setActive,
2234            boolean useCurrent, Tab parent) {
2235        Tab tab = createNewTab(incognito, setActive, useCurrent);
2236        if (tab != null) {
2237            if (parent != null && parent != tab) {
2238                parent.addChildTab(tab);
2239            }
2240            if (url != null) {
2241                loadUrl(tab, url);
2242            }
2243        }
2244        return tab;
2245    }
2246
2247    // this method will attempt to create a new tab
2248    // incognito: private browsing tab
2249    // setActive: ste tab as current tab
2250    // useCurrent: if no new tab can be created, return current tab
2251    private Tab createNewTab(boolean incognito, boolean setActive,
2252            boolean useCurrent) {
2253        Tab tab = null;
2254        if (mTabControl.canCreateNewTab()) {
2255            tab = mTabControl.createNewTab(incognito);
2256            addTab(tab);
2257            if (setActive) {
2258                setActiveTab(tab);
2259            }
2260        } else {
2261            if (useCurrent) {
2262                tab = mTabControl.getCurrentTab();
2263                reuseTab(tab, null);
2264            } else {
2265                mUi.showMaxTabsWarning();
2266            }
2267        }
2268        return tab;
2269    }
2270
2271    @Override
2272    public SnapshotTab createNewSnapshotTab(long snapshotId, boolean setActive) {
2273        SnapshotTab tab = null;
2274        if (mTabControl.canCreateNewTab()) {
2275            tab = mTabControl.createSnapshotTab(snapshotId);
2276            addTab(tab);
2277            if (setActive) {
2278                setActiveTab(tab);
2279            }
2280        } else {
2281            mUi.showMaxTabsWarning();
2282        }
2283        return tab;
2284    }
2285
2286    /**
2287     * @param tab the tab to switch to
2288     * @return boolean True if we successfully switched to a different tab.  If
2289     *                 the indexth tab is null, or if that tab is the same as
2290     *                 the current one, return false.
2291     */
2292    @Override
2293    public boolean switchToTab(Tab tab) {
2294        Tab currentTab = mTabControl.getCurrentTab();
2295        if (tab == null || tab == currentTab) {
2296            return false;
2297        }
2298        setActiveTab(tab);
2299        return true;
2300    }
2301
2302    @Override
2303    public void closeCurrentTab() {
2304        if (mTabControl.getTabCount() == 1) {
2305            mCrashRecoveryHandler.clearState();
2306            mTabControl.removeTab(getCurrentTab());
2307            mActivity.finish();
2308            return;
2309        }
2310        final Tab current = mTabControl.getCurrentTab();
2311        final int pos = mTabControl.getCurrentPosition();
2312        Tab newTab = current.getParent();
2313        if (newTab == null) {
2314            newTab = mTabControl.getTab(pos + 1);
2315            if (newTab == null) {
2316                newTab = mTabControl.getTab(pos - 1);
2317            }
2318        }
2319        if (switchToTab(newTab)) {
2320            // Close window
2321            closeTab(current);
2322        }
2323    }
2324
2325    /**
2326     * Close the tab, remove its associated title bar, and adjust mTabControl's
2327     * current tab to a valid value.
2328     */
2329    @Override
2330    public void closeTab(Tab tab) {
2331        removeTab(tab);
2332    }
2333
2334    // Called when loading from context menu or LOAD_URL message
2335    protected void loadUrlFromContext(String url) {
2336        Tab tab = getCurrentTab();
2337        WebView view = tab != null ? tab.getWebView() : null;
2338        // In case the user enters nothing.
2339        if (url != null && url.length() != 0 && tab != null && view != null) {
2340            url = UrlUtils.smartUrlFilter(url);
2341            if (!view.getWebViewClient().shouldOverrideUrlLoading(view, url)) {
2342                loadUrl(tab, url);
2343            }
2344        }
2345    }
2346
2347    /**
2348     * Load the URL into the given WebView and update the title bar
2349     * to reflect the new load.  Call this instead of WebView.loadUrl
2350     * directly.
2351     * @param view The WebView used to load url.
2352     * @param url The URL to load.
2353     */
2354    @Override
2355    public void loadUrl(Tab tab, String url) {
2356        loadUrl(tab, url, null);
2357    }
2358
2359    protected void loadUrl(Tab tab, String url, Map<String, String> headers) {
2360        if (tab != null) {
2361            dismissSubWindow(tab);
2362            tab.loadUrl(url, headers);
2363        }
2364    }
2365
2366    /**
2367     * Load UrlData into a Tab and update the title bar to reflect the new
2368     * load.  Call this instead of UrlData.loadIn directly.
2369     * @param t The Tab used to load.
2370     * @param data The UrlData being loaded.
2371     */
2372    protected void loadUrlDataIn(Tab t, UrlData data) {
2373        if (data != null) {
2374            if (data.mVoiceIntent != null) {
2375                t.activateVoiceSearchMode(data.mVoiceIntent);
2376            } else if (data.isPreloaded()) {
2377                // this isn't called for preloaded tabs
2378            } else {
2379                loadUrl(t, data.mUrl, data.mHeaders);
2380            }
2381        }
2382    }
2383
2384    @Override
2385    public void onUserCanceledSsl(Tab tab) {
2386        // TODO: Figure out the "right" behavior
2387        if (tab.canGoBack()) {
2388            tab.goBack();
2389        } else {
2390            tab.loadUrl(mSettings.getHomePage(), null);
2391        }
2392    }
2393
2394    void goBackOnePageOrQuit() {
2395        Tab current = mTabControl.getCurrentTab();
2396        if (current == null) {
2397            /*
2398             * Instead of finishing the activity, simply push this to the back
2399             * of the stack and let ActivityManager to choose the foreground
2400             * activity. As BrowserActivity is singleTask, it will be always the
2401             * root of the task. So we can use either true or false for
2402             * moveTaskToBack().
2403             */
2404            mActivity.moveTaskToBack(true);
2405            return;
2406        }
2407        if (current.canGoBack()) {
2408            current.goBack();
2409        } else {
2410            // Check to see if we are closing a window that was created by
2411            // another window. If so, we switch back to that window.
2412            Tab parent = current.getParent();
2413            if (parent != null) {
2414                switchToTab(parent);
2415                // Now we close the other tab
2416                closeTab(current);
2417            } else {
2418                if ((current.getAppId() != null) || current.closeOnBack()) {
2419                    closeCurrentTab();
2420                }
2421                /*
2422                 * Instead of finishing the activity, simply push this to the back
2423                 * of the stack and let ActivityManager to choose the foreground
2424                 * activity. As BrowserActivity is singleTask, it will be always the
2425                 * root of the task. So we can use either true or false for
2426                 * moveTaskToBack().
2427                 */
2428                mActivity.moveTaskToBack(true);
2429            }
2430        }
2431    }
2432
2433    /**
2434     * Feed the previously stored results strings to the BrowserProvider so that
2435     * the SearchDialog will show them instead of the standard searches.
2436     * @param result String to show on the editable line of the SearchDialog.
2437     */
2438    @Override
2439    public void showVoiceSearchResults(String result) {
2440        ContentProviderClient client = mActivity.getContentResolver()
2441                .acquireContentProviderClient(Browser.BOOKMARKS_URI);
2442        ContentProvider prov = client.getLocalContentProvider();
2443        BrowserProvider bp = (BrowserProvider) prov;
2444        bp.setQueryResults(mTabControl.getCurrentTab().getVoiceSearchResults());
2445        client.release();
2446
2447        Bundle bundle = createGoogleSearchSourceBundle(
2448                GOOGLE_SEARCH_SOURCE_SEARCHKEY);
2449        bundle.putBoolean(SearchManager.CONTEXT_IS_VOICE, true);
2450        startSearch(result, false, bundle, false);
2451    }
2452
2453    private void startSearch(String initialQuery, boolean selectInitialQuery,
2454            Bundle appSearchData, boolean globalSearch) {
2455        if (appSearchData == null) {
2456            appSearchData = createGoogleSearchSourceBundle(
2457                    GOOGLE_SEARCH_SOURCE_TYPE);
2458        }
2459
2460        SearchEngine searchEngine = mSettings.getSearchEngine();
2461        if (searchEngine != null && !searchEngine.supportsVoiceSearch()) {
2462            appSearchData.putBoolean(SearchManager.DISABLE_VOICE_SEARCH, true);
2463        }
2464        mActivity.startSearch(initialQuery, selectInitialQuery, appSearchData,
2465                globalSearch);
2466    }
2467
2468    private Bundle createGoogleSearchSourceBundle(String source) {
2469        Bundle bundle = new Bundle();
2470        bundle.putString(Search.SOURCE, source);
2471        return bundle;
2472    }
2473
2474    /**
2475     * helper method for key handler
2476     * returns the current tab if it can't advance
2477     */
2478    private Tab getNextTab() {
2479        return mTabControl.getTab(Math.min(mTabControl.getTabCount() - 1,
2480                mTabControl.getCurrentPosition() + 1));
2481    }
2482
2483    /**
2484     * helper method for key handler
2485     * returns the current tab if it can't advance
2486     */
2487    private Tab getPrevTab() {
2488        return  mTabControl.getTab(Math.max(0,
2489                mTabControl.getCurrentPosition() - 1));
2490    }
2491
2492    /**
2493     * handle key events in browser
2494     *
2495     * @param keyCode
2496     * @param event
2497     * @return true if handled, false to pass to super
2498     */
2499    boolean onKeyDown(int keyCode, KeyEvent event) {
2500        boolean noModifiers = event.hasNoModifiers();
2501        // Even if MENU is already held down, we need to call to super to open
2502        // the IME on long press.
2503        if (!noModifiers
2504                && ((KeyEvent.KEYCODE_MENU == keyCode)
2505                        || (KeyEvent.KEYCODE_CTRL_LEFT == keyCode)
2506                        || (KeyEvent.KEYCODE_CTRL_RIGHT == keyCode))) {
2507            mMenuIsDown = true;
2508            return false;
2509        }
2510
2511        WebView webView = getCurrentTopWebView();
2512        Tab tab = getCurrentTab();
2513        if (webView == null || tab == null) return false;
2514
2515        boolean ctrl = event.hasModifiers(KeyEvent.META_CTRL_ON);
2516        boolean shift = event.hasModifiers(KeyEvent.META_SHIFT_ON);
2517
2518        switch(keyCode) {
2519            case KeyEvent.KEYCODE_TAB:
2520                if (event.isCtrlPressed()) {
2521                    if (event.isShiftPressed()) {
2522                        // prev tab
2523                        switchToTab(getPrevTab());
2524                    } else {
2525                        // next tab
2526                        switchToTab(getNextTab());
2527                    }
2528                    return true;
2529                }
2530                break;
2531            case KeyEvent.KEYCODE_SPACE:
2532                // WebView/WebTextView handle the keys in the KeyDown. As
2533                // the Activity's shortcut keys are only handled when WebView
2534                // doesn't, have to do it in onKeyDown instead of onKeyUp.
2535                if (shift) {
2536                    pageUp();
2537                } else if (noModifiers) {
2538                    pageDown();
2539                }
2540                return true;
2541            case KeyEvent.KEYCODE_BACK:
2542                if (!noModifiers) break;
2543                event.startTracking();
2544                return true;
2545            case KeyEvent.KEYCODE_FORWARD:
2546                if (!noModifiers) break;
2547                tab.goForward();
2548                return true;
2549            case KeyEvent.KEYCODE_DPAD_LEFT:
2550                if (ctrl) {
2551                    tab.goBack();
2552                    return true;
2553                }
2554                break;
2555            case KeyEvent.KEYCODE_DPAD_RIGHT:
2556                if (ctrl) {
2557                    tab.goForward();
2558                    return true;
2559                }
2560                break;
2561            case KeyEvent.KEYCODE_A:
2562                if (ctrl) {
2563                    webView.selectAll();
2564                    return true;
2565                }
2566                break;
2567//          case KeyEvent.KEYCODE_B:    // menu
2568            case KeyEvent.KEYCODE_C:
2569                if (ctrl) {
2570                    webView.copySelection();
2571                    return true;
2572                }
2573                break;
2574//          case KeyEvent.KEYCODE_D:    // menu
2575//          case KeyEvent.KEYCODE_E:    // in Chrome: puts '?' in URL bar
2576//          case KeyEvent.KEYCODE_F:    // menu
2577//          case KeyEvent.KEYCODE_G:    // in Chrome: finds next match
2578//          case KeyEvent.KEYCODE_H:    // menu
2579//          case KeyEvent.KEYCODE_I:    // unused
2580//          case KeyEvent.KEYCODE_J:    // menu
2581//          case KeyEvent.KEYCODE_K:    // in Chrome: puts '?' in URL bar
2582//          case KeyEvent.KEYCODE_L:    // menu
2583//          case KeyEvent.KEYCODE_M:    // unused
2584//          case KeyEvent.KEYCODE_N:    // in Chrome: new window
2585//          case KeyEvent.KEYCODE_O:    // in Chrome: open file
2586//          case KeyEvent.KEYCODE_P:    // in Chrome: print page
2587//          case KeyEvent.KEYCODE_Q:    // unused
2588//          case KeyEvent.KEYCODE_R:
2589//          case KeyEvent.KEYCODE_S:    // in Chrome: saves page
2590            case KeyEvent.KEYCODE_T:
2591                // we can't use the ctrl/shift flags, they check for
2592                // exclusive use of a modifier
2593                if (event.isCtrlPressed()) {
2594                    if (event.isShiftPressed()) {
2595                        openIncognitoTab();
2596                    } else {
2597                        openTabToHomePage();
2598                    }
2599                    return true;
2600                }
2601                break;
2602//          case KeyEvent.KEYCODE_U:    // in Chrome: opens source of page
2603//          case KeyEvent.KEYCODE_V:    // text view intercepts to paste
2604            case KeyEvent.KEYCODE_W:    // in Chrome: close tab
2605                if (ctrl) {
2606                    closeCurrentTab();
2607                    return true;
2608                }
2609                break;
2610//          case KeyEvent.KEYCODE_X:    // text view intercepts to cut
2611//          case KeyEvent.KEYCODE_Y:    // unused
2612//          case KeyEvent.KEYCODE_Z:    // unused
2613        }
2614        // it is a regular key and webview is not null
2615         return mUi.dispatchKey(keyCode, event);
2616    }
2617
2618    boolean onKeyLongPress(int keyCode, KeyEvent event) {
2619        switch(keyCode) {
2620        case KeyEvent.KEYCODE_BACK:
2621            if (mUi.showsWeb()) {
2622                bookmarksOrHistoryPicker(true);
2623                return true;
2624            }
2625            break;
2626        }
2627        return false;
2628    }
2629
2630    boolean onKeyUp(int keyCode, KeyEvent event) {
2631        if (KeyEvent.KEYCODE_MENU == keyCode) {
2632            mMenuIsDown = false;
2633            if (event.isTracking() && !event.isCanceled()) {
2634                return onMenuKey();
2635            }
2636        }
2637        if (!event.hasNoModifiers()) return false;
2638        switch(keyCode) {
2639            case KeyEvent.KEYCODE_BACK:
2640                if (event.isTracking() && !event.isCanceled()) {
2641                    onBackKey();
2642                    return true;
2643                }
2644                break;
2645        }
2646        return false;
2647    }
2648
2649    public boolean isMenuDown() {
2650        return mMenuIsDown;
2651    }
2652
2653    public void setupAutoFill(Message message) {
2654        // Open the settings activity at the AutoFill profile fragment so that
2655        // the user can create a new profile. When they return, we will dispatch
2656        // the message so that we can autofill the form using their new profile.
2657        Intent intent = new Intent(mActivity, BrowserPreferencesPage.class);
2658        intent.putExtra(PreferenceActivity.EXTRA_SHOW_FRAGMENT,
2659                AutoFillSettingsFragment.class.getName());
2660        mAutoFillSetupMessage = message;
2661        mActivity.startActivityForResult(intent, AUTOFILL_SETUP);
2662    }
2663
2664    @Override
2665    public void registerDropdownChangeListener(DropdownChangeListener d) {
2666        mUi.registerDropdownChangeListener(d);
2667    }
2668
2669    public boolean onSearchRequested() {
2670        mUi.editUrl(false);
2671        return true;
2672    }
2673
2674    @Override
2675    public boolean shouldCaptureThumbnails() {
2676        return mUi.shouldCaptureThumbnails();
2677    }
2678
2679}
2680