src/com/android/browser/TabControl.java

   1 /*
   2  * Copyright (C) 2007 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
  17 package com.android.browser;
  18
  19 import android.content.Context;
  20 import android.graphics.Picture;
  21 import android.net.http.SslError;
  22 import android.os.Bundle;
  23 import android.os.Message;
  24 import android.util.Log;
  25 import android.view.Gravity;
  26 import android.view.LayoutInflater;
  27 import android.view.View;
  28 import android.view.ViewGroup;
  29 import android.view.View.OnClickListener;
  30 import android.webkit.HttpAuthHandler;
  31 import android.webkit.JsPromptResult;
  32 import android.webkit.JsResult;
  33 import android.webkit.SslErrorHandler;
  34 import android.webkit.WebBackForwardList;
  35 import android.webkit.WebChromeClient;
  36 import android.webkit.WebHistoryItem;
  37 import android.webkit.WebView;
  38 import android.webkit.WebViewClient;
  39 import android.widget.FrameLayout;
  40 import android.widget.ImageButton;
  41
  42 import java.io.File;
  43 import java.io.FileInputStream;
  44 import java.util.ArrayList;
  45 import java.util.Vector;
  46
  47 class TabControl {
  48     // Log Tag
  49     private static final String LOGTAG = "TabControl";
  50     // Maximum number of tabs.
  51     static final int MAX_TABS = 8;
  52     // Static instance of an empty callback.
  53     private static final WebViewClient mEmptyClient =
  54             new WebViewClient();
  55     // Instance of BackgroundChromeClient for background tabs.
  56     private final BackgroundChromeClient mBackgroundChromeClient =
  57             new BackgroundChromeClient();
  58     // Private array of WebViews that are used as tabs.
  59     private ArrayList<Tab> mTabs = new ArrayList<Tab>(MAX_TABS);
  60     // Queue of most recently viewed tabs.
  61     private ArrayList<Tab> mTabQueue = new ArrayList<Tab>(MAX_TABS);
  62     // Current position in mTabs.
  63     private int mCurrentTab = -1;
  64     // A private instance of BrowserActivity to interface with when adding and
  65     // switching between tabs.
  66     private final BrowserActivity mActivity;
  67     // Inflation service for making subwindows.
  68     private final LayoutInflater mInflateService;
  69     // Subclass of WebViewClient used in subwindows to notify the main
  70     // WebViewClient of certain WebView activities.
  71     private class SubWindowClient extends WebViewClient {
  72         // The main WebViewClient.
  73         private final WebViewClient mClient;
  74
  75         SubWindowClient(WebViewClient client) {
  76             mClient = client;
  77         }
  78         @Override
  79         public void doUpdateVisitedHistory(WebView view, String url,
  80                 boolean isReload) {
  81             mClient.doUpdateVisitedHistory(view, url, isReload);
  82         }
  83         @Override
  84         public boolean shouldOverrideUrlLoading(WebView view, String url) {
  85             return mClient.shouldOverrideUrlLoading(view, url);
  86         }
  87         @Override
  88         public void onReceivedSslError(WebView view, SslErrorHandler handler,
  89                 SslError error) {
  90             mClient.onReceivedSslError(view, handler, error);
  91         }
  92         @Override
  93         public void onReceivedHttpAuthRequest(WebView view,
  94                 HttpAuthHandler handler, String host, String realm) {
  95             mClient.onReceivedHttpAuthRequest(view, handler, host, realm);
  96         }
  97         @Override
  98         public void onFormResubmission(WebView view, Message dontResend,
  99                 Message resend) {
 100             mClient.onFormResubmission(view, dontResend, resend);
 101         }
 102         @Override
 103         public void onReceivedError(WebView view, int errorCode,
 104                 String description, String failingUrl) {
 105             mClient.onReceivedError(view, errorCode, description, failingUrl);
 106         }
 107     }
 108     // Subclass of WebChromeClient to display javascript dialogs.
 109     private class SubWindowChromeClient extends WebChromeClient {
 110         // This subwindow's tab.
 111         private final Tab mTab;
 112         // The main WebChromeClient.
 113         private final WebChromeClient mClient;
 114
 115         SubWindowChromeClient(Tab t, WebChromeClient client) {
 116             mTab = t;
 117             mClient = client;
 118         }
 119         @Override
 120         public void onProgressChanged(WebView view, int newProgress) {
 121             mClient.onProgressChanged(view, newProgress);
 122         }
 123         @Override
 124         public boolean onCreateWindow(WebView view, boolean dialog,
 125                 boolean userGesture, android.os.Message resultMsg) {
 126             return mClient.onCreateWindow(view, dialog, userGesture, resultMsg);
 127         }
 128         @Override
 129         public void onCloseWindow(WebView window) {
 130             if (Browser.DEBUG && window != mTab.mSubView) {
 131                 throw new AssertionError("Can't close the window");
 132             }
 133             mActivity.dismissSubWindow(mTab);
 134         }
 135     }
 136     // Background WebChromeClient for focusing tabs
 137     private class BackgroundChromeClient extends WebChromeClient {
 138         @Override
 139         public void onRequestFocus(WebView view) {
 140             Tab t = getTabFromView(view);
 141             if (t != getCurrentTab()) {
 142                 mActivity.showTab(t);
 143             }
 144         }
 145     }
 146
 147     // Extra saved information for displaying the tab in the picker.
 148     public static class PickerData {
 149         String  mUrl;
 150         String  mTitle;
 151         float   mScale;
 152         int     mScrollX;
 153         int     mScrollY;
 154         int     mWidth;
 155         Picture mPicture;
 156         // This can be null. When a new picture comes in, this view should be
 157         // invalidated to show the new picture.
 158         FakeWebView mFakeWebView;
 159     }
 160
 161     /**
 162      * Private class for maintaining Tabs with a main WebView and a subwindow.
 163      */
 164     public class Tab implements WebView.PictureListener {
 165         // Main WebView
 166         private WebView mMainView;
 167         // Subwindow WebView
 168         private WebView mSubView;
 169         // Subwindow container
 170         private View mSubViewContainer;
 171         // Subwindow callback
 172         private SubWindowClient mSubViewClient;
 173         // Subwindow chrome callback
 174         private SubWindowChromeClient mSubViewChromeClient;
 175         // Saved bundle for when we are running low on memory. It contains the
 176         // information needed to restore the WebView if the user goes back to
 177         // the tab.
 178         private Bundle mSavedState;
 179         // Data used when displaying the tab in the picker.
 180         private PickerData mPickerData;
 181
 182         // Parent Tab. This is the Tab that created this Tab, or null
 183         // if the Tab was created by the UI
 184         private Tab mParentTab;
 185         // Tab that constructed by this Tab. This is used when this
 186         // Tab is destroyed, it clears all mParentTab values in the
 187         // children.
 188         private Vector<Tab> mChildTabs;
 189
 190         private Boolean mCloseOnExit;
 191         // Application identifier used to find tabs that another application
 192         // wants to reuse.
 193         private String mAppId;
 194         // Keep the original url around to avoid killing the old WebView if the
 195         // url has not changed.
 196         private String mOriginalUrl;
 197
 198         // Construct a new tab
 199         private Tab(WebView w, boolean closeOnExit, String appId, String url) {
 200             mMainView = w;
 201             mCloseOnExit = closeOnExit;
 202             mAppId = appId;
 203             mOriginalUrl = url;
 204         }
 205
 206         /**
 207          * Return the top window of this tab; either the subwindow if it is not
 208          * null or the main window.
 209          * @return The top window of this tab.
 210          */
 211         public WebView getTopWindow() {
 212             if (mSubView != null) {
 213                 return mSubView;
 214             }
 215             return mMainView;
 216         }
 217
 218         /**
 219          * Return the main window of this tab. Note: if a tab is freed in the
 220          * background, this can return null. It is only guaranteed to be
 221          * non-null for the current tab.
 222          * @return The main WebView of this tab.
 223          */
 224         public WebView getWebView() {
 225             return mMainView;
 226         }
 227
 228         /**
 229          * Return the subwindow of this tab or null if there is no subwindow.
 230          * @return The subwindow of this tab or null.
 231          */
 232         public WebView getSubWebView() {
 233             return mSubView;
 234         }
 235
 236         /**
 237          * Return the subwindow container of this tab or null if there is no
 238          * subwindow.
 239          * @return The subwindow's container View.
 240          */
 241         public View getSubWebViewContainer() {
 242             return mSubViewContainer;
 243         }
 244
 245         /**
 246          * Get the url of this tab.  Valid after calling populatePickerData, but
 247          * before calling wipePickerData, or if the webview has been destroyed.
 248          *
 249          * @return The WebView's url or null.
 250          */
 251         public String getUrl() {
 252             if (mPickerData != null) {
 253                 return mPickerData.mUrl;
 254             }
 255             return null;
 256         }
 257
 258         /**
 259          * Get the title of this tab.  Valid after calling populatePickerData,
 260          * but before calling wipePickerData, or if the webview has been
 261          * destroyed.  If the url has no title, use the url instead.
 262          *
 263          * @return The WebView's title (or url) or null.
 264          */
 265         public String getTitle() {
 266             if (mPickerData != null) {
 267                 return mPickerData.mTitle;
 268             }
 269             return null;
 270         }
 271
 272         /**
 273          * Returns the picker data.
 274          */
 275         public PickerData getPickerData() {
 276             return mPickerData;
 277         }
 278
 279         private void setParentTab(Tab parent) {
 280             mParentTab = parent;
 281             // This tab may have been freed due to low memory. If that is the
 282             // case, the parent tab index is already saved. If we are changing
 283             // that index (most likely due to removing the parent tab) we must
 284             // update the parent tab index in the saved Bundle.
 285             if (mSavedState != null) {
 286                 if (parent == null) {
 287                     mSavedState.remove(PARENTTAB);
 288                 } else {
 289                     mSavedState.putInt(PARENTTAB, getTabIndex(parent));
 290                 }
 291             }
 292         }
 293
 294         /**
 295          * When a Tab is created through the content of another Tab, then
 296          * we associate the Tabs.
 297          * @param child the Tab that was created from this Tab
 298          */
 299         public void addChildTab(Tab child) {
 300             if (mChildTabs == null) {
 301                 mChildTabs = new Vector<Tab>();
 302             }
 303             mChildTabs.add(child);
 304             child.setParentTab(this);
 305         }
 306
 307         private void removeFromTree() {
 308             // detach the children
 309             if (mChildTabs != null) {
 310                 for(Tab t : mChildTabs) {
 311                     t.setParentTab(null);
 312                 }
 313             }
 314
 315             // Find myself in my parent list
 316             if (mParentTab != null) {
 317                 mParentTab.mChildTabs.remove(this);
 318             }
 319         }
 320
 321         /**
 322          * If this Tab was created through another Tab, then this method
 323          * returns that Tab.
 324          * @return the Tab parent or null
 325          */
 326         public Tab getParentTab() {
 327             return mParentTab;
 328         }
 329
 330         /**
 331          * Return whether this tab should be closed when it is backing out of
 332          * the first page.
 333          * @return TRUE if this tab should be closed when exit.
 334          */
 335         public boolean closeOnExit() {
 336             return mCloseOnExit;
 337         }
 338
 339         public void onNewPicture(WebView view, Picture p) {
 340             if (mPickerData == null) {
 341                 return;
 342             }
 343
 344             mPickerData.mPicture = p;
 345             // Tell the FakeWebView to redraw.
 346             if (mPickerData.mFakeWebView != null) {
 347                 mPickerData.mFakeWebView.invalidate();
 348             }
 349         }
 350     };
 351
 352     // Directory to store thumbnails for each WebView.
 353     private final File mThumbnailDir;
 354
 355     /**
 356      * Construct a new TabControl object that interfaces with the given
 357      * BrowserActivity instance.
 358      * @param activity A BrowserActivity instance that TabControl will interface
 359      *                 with.
 360      */
 361     TabControl(BrowserActivity activity) {
 362         mActivity = activity;
 363         mInflateService =
 364                 ((LayoutInflater) activity.getSystemService(
 365                         Context.LAYOUT_INFLATER_SERVICE));
 366         mThumbnailDir = activity.getDir("thumbnails", 0);
 367     }
 368
 369     File getThumbnailDir() {
 370         return mThumbnailDir;
 371     }
 372
 373     BrowserActivity getBrowserActivity() {
 374         return mActivity;
 375     }
 376
 377     /**
 378      * Return the current tab's main WebView. This will always return the main
 379      * WebView for a given tab and not a subwindow.
 380      * @return The current tab's WebView.
 381      */
 382     WebView getCurrentWebView() {
 383         Tab t = getTab(mCurrentTab);
 384         if (t == null) {
 385             return null;
 386         }
 387         return t.mMainView;
 388     }
 389
 390     /**
 391      * Return the current tab's top-level WebView. This can return a subwindow
 392      * if one exists.
 393      * @return The top-level WebView of the current tab.
 394      */
 395     WebView getCurrentTopWebView() {
 396         Tab t = getTab(mCurrentTab);
 397         if (t == null) {
 398             return null;
 399         }
 400         return t.mSubView != null ? t.mSubView : t.mMainView;
 401     }
 402
 403     /**
 404      * Return the current tab's subwindow if it exists.
 405      * @return The subwindow of the current tab or null if it doesn't exist.
 406      */
 407     WebView getCurrentSubWindow() {
 408         Tab t = getTab(mCurrentTab);
 409         if (t == null) {
 410             return null;
 411         }
 412         return t.mSubView;
 413     }
 414
 415     /**
 416      * Return the tab at the specified index.
 417      * @return The Tab for the specified index or null if the tab does not
 418      *         exist.
 419      */
 420     Tab getTab(int index) {
 421         if (index >= 0 && index < mTabs.size()) {
 422             return mTabs.get(index);
 423         }
 424         return null;
 425     }
 426
 427     /**
 428      * Return the current tab.
 429      * @return The current tab.
 430      */
 431     Tab getCurrentTab() {
 432         return getTab(mCurrentTab);
 433     }
 434
 435     /**
 436      * Return the current tab index.
 437      * @return The current tab index
 438      */
 439     int getCurrentIndex() {
 440         return mCurrentTab;
 441     }
 442
 443     /**
 444      * Given a Tab, find it's index
 445      * @param Tab to find
 446      * @return index of Tab or -1 if not found
 447      */
 448     int getTabIndex(Tab tab) {
 449         if (tab == null) {
 450             return -1;
 451         }
 452         return mTabs.indexOf(tab);
 453     }
 454
 455     /**
 456      * Create a new tab.
 457      * @return The newly createTab or null if we have reached the maximum
 458      *         number of open tabs.
 459      */
 460     Tab createNewTab(boolean closeOnExit, String appId, String url) {
 461         int size = mTabs.size();
 462         // Return false if we have maxed out on tabs
 463         if (MAX_TABS == size) {
 464             return null;
 465         }
 466         final WebView w = createNewWebView();
 467         // Create a new tab and add it to the tab list
 468         Tab t = new Tab(w, closeOnExit, appId, url);
 469         mTabs.add(t);
 470         // Initially put the tab in the background.
 471         putTabInBackground(t);
 472         return t;
 473     }
 474
 475     /**
 476      * Create a new tab with default values for closeOnExit(false),
 477      * appId(null), and url(null).
 478      */
 479     Tab createNewTab() {
 480         return createNewTab(false, null, null);
 481     }
 482
 483     /**
 484      * Remove the tab from the list. If the tab is the current tab shown, the
 485      * last created tab will be shown.
 486      * @param t The tab to be removed.
 487      */
 488     boolean removeTab(Tab t) {
 489         if (t == null) {
 490             return false;
 491         }
 492         // Only remove the tab if it is the current one.
 493         if (getCurrentTab() == t) {
 494             putTabInBackground(t);
 495         }
 496
 497         // Only destroy the WebView if it still exists.
 498         if (t.mMainView != null) {
 499             // Take down the sub window.
 500             dismissSubWindow(t);
 501             // Remove the WebView's settings from the BrowserSettings list of
 502             // observers.
 503             BrowserSettings.getInstance().deleteObserver(
 504                     t.mMainView.getSettings());
 505             // Destroy the main view and subview
 506             t.mMainView.destroy();
 507             t.mMainView = null;
 508         }
 509         // clear it's references to parent and children
 510         t.removeFromTree();
 511
 512         // Remove it from our list of tabs.
 513         mTabs.remove(t);
 514
 515         // The tab indices have shifted, update all the saved state so we point
 516         // to the correct index.
 517         for (Tab tab : mTabs) {
 518             if (tab.mChildTabs != null) {
 519                 for (Tab child : tab.mChildTabs) {
 520                     child.setParentTab(tab);
 521                 }
 522             }
 523         }
 524
 525
 526         // This tab may have been pushed in to the background and then closed.
 527         // If the saved state contains a picture file, delete the file.
 528         if (t.mSavedState != null) {
 529             if (t.mSavedState.containsKey(CURRPICTURE)) {
 530                 new File(t.mSavedState.getString(CURRPICTURE)).delete();
 531             }
 532         }
 533
 534         // Remove it from the queue of viewed tabs.
 535         mTabQueue.remove(t);
 536         mCurrentTab = -1;
 537         return true;
 538     }
 539
 540     /**
 541      * Clear the back/forward list for all the current tabs.
 542      */
 543     void clearHistory() {
 544         int size = getTabCount();
 545         for (int i = 0; i < size; i++) {
 546             Tab t = mTabs.get(i);
 547             // TODO: if a tab is freed due to low memory, its history is not
 548             // cleared here.
 549             if (t.mMainView != null) {
 550                 t.mMainView.clearHistory();
 551             }
 552             if (t.mSubView != null) {
 553                 t.mSubView.clearHistory();
 554             }
 555         }
 556     }
 557
 558     /**
 559      * Destroy all the tabs and subwindows
 560      */
 561     void destroy() {
 562         BrowserSettings s = BrowserSettings.getInstance();
 563         for (Tab t : mTabs) {
 564             if (t.mMainView != null) {
 565                 dismissSubWindow(t);
 566                 s.deleteObserver(t.mMainView.getSettings());
 567                 t.mMainView.destroy();
 568                 t.mMainView = null;
 569             }
 570         }
 571         mTabs.clear();
 572         mTabQueue.clear();
 573     }
 574
 575     /**
 576      * Returns the number of tabs created.
 577      * @return The number of tabs created.
 578      */
 579     int getTabCount() {
 580         return mTabs.size();
 581     }
 582
 583     // Used for saving and restoring each Tab
 584     private static final String WEBVIEW = "webview";
 585     private static final String NUMTABS = "numTabs";
 586     private static final String CURRTAB = "currentTab";
 587     private static final String CURRURL = "currentUrl";
 588     private static final String CURRTITLE = "currentTitle";
 589     private static final String CURRWIDTH = "currentWidth";
 590     private static final String CURRPICTURE = "currentPicture";
 591     private static final String CLOSEONEXIT = "closeonexit";
 592     private static final String PARENTTAB = "parentTab";
 593     private static final String APPID = "appid";
 594     private static final String ORIGINALURL = "originalUrl";
 595
 596     /**
 597      * Save the state of all the Tabs.
 598      * @param outState The Bundle to save the state to.
 599      */
 600     void saveState(Bundle outState) {
 601         final int numTabs = getTabCount();
 602         outState.putInt(NUMTABS, numTabs);
 603         final int index = getCurrentIndex();
 604         outState.putInt(CURRTAB, (index >= 0 && index < numTabs) ? index : 0);
 605         for (int i = 0; i < numTabs; i++) {
 606             final Tab t = getTab(i);
 607             if (saveState(t)) {
 608                 outState.putBundle(WEBVIEW + i, t.mSavedState);
 609             }
 610         }
 611     }
 612
 613     /**
 614      * Restore the state of all the tabs.
 615      * @param inState The saved state of all the tabs.
 616      * @return True if there were previous tabs that were restored. False if
 617      *         there was no saved state or restoring the state failed.
 618      */
 619     boolean restoreState(Bundle inState) {
 620         final int numTabs = (inState == null)
 621                 ? -1 : inState.getInt(NUMTABS, -1);
 622         if (numTabs == -1) {
 623             return false;
 624         } else {
 625             final int currentTab = inState.getInt(CURRTAB, -1);
 626             for (int i = 0; i < numTabs; i++) {
 627                 if (i == currentTab) {
 628                     Tab t = createNewTab();
 629                     // Me must set the current tab before restoring the state
 630                     // so that all the client classes are set.
 631                     setCurrentTab(t);
 632                     if (!restoreState(inState.getBundle(WEBVIEW + i), t)) {
 633                         Log.w(LOGTAG, "Fail in restoreState, load home page.");
 634                         t.mMainView.loadUrl(BrowserSettings.getInstance()
 635                                 .getHomePage());
 636                     }
 637                 } else {
 638                     // Create a new tab and don't restore the state yet, add it
 639                     // to the tab list
 640                     Tab t = new Tab(null, false, null, null);
 641                     t.mSavedState = inState.getBundle(WEBVIEW + i);
 642                     if (t.mSavedState != null) {
 643                         populatePickerDataFromSavedState(t);
 644                         // Need to maintain the app id and original url so we
 645                         // can possibly reuse this tab.
 646                         t.mAppId = t.mSavedState.getString(APPID);
 647                         t.mOriginalUrl = t.mSavedState.getString(ORIGINALURL);
 648                     }
 649                     mTabs.add(t);
 650                     mTabQueue.add(t);
 651                 }
 652             }
 653             // Rebuild the tree of tabs. Do this after all tabs have been
 654             // created/restored so that the parent tab exists.
 655             for (int i = 0; i < numTabs; i++) {
 656                 final Bundle b = inState.getBundle(WEBVIEW + i);
 657                 final Tab t = getTab(i);
 658                 if (b != null && t != null) {
 659                     final int parentIndex = b.getInt(PARENTTAB, -1);
 660                     if (parentIndex != -1) {
 661                         final Tab parent = getTab(parentIndex);
 662                         if (parent != null) {
 663                             parent.addChildTab(t);
 664                         }
 665                     }
 666                 }
 667             }
 668         }
 669         return true;
 670     }
 671
 672     /**
 673      * Free the memory in this order, 1) free the background tab; 2) free the
 674      * WebView cache;
 675      */
 676     void freeMemory() {
 677         // free the least frequently used background tab
 678         Tab t = getLeastUsedTab();
 679         if (t != null) {
 680             Log.w(LOGTAG, "Free a tab in the browser");
 681             freeTab(t);
 682             // force a gc
 683             System.gc();
 684             return;
 685         }
 686
 687         // free the WebView cache
 688         Log.w(LOGTAG, "Free WebView cache");
 689         WebView view = getCurrentWebView();
 690         if (view != null) {
 691             view.clearCache(false);
 692         }
 693         // force a gc
 694         System.gc();
 695     }
 696
 697     private Tab getLeastUsedTab() {
 698         // Don't do anything if we only have 1 tab.
 699         if (getTabCount() == 1) {
 700             return null;
 701         }
 702
 703         // Rip through the queue starting at the beginning and teardown the
 704         // next available tab.
 705         Tab t = null;
 706         int i = 0;
 707         final int queueSize = mTabQueue.size();
 708         if (queueSize == 0) {
 709             return null;
 710         }
 711         do {
 712             t = mTabQueue.get(i++);
 713         } while (i < queueSize && t != null && t.mMainView == null);
 714
 715         // Don't do anything if the last remaining tab is the current one.
 716         if (t == getCurrentTab()) {
 717             return null;
 718         }
 719
 720         return t;
 721     }
 722
 723     private void freeTab(Tab t) {
 724         // Store the WebView's state.
 725         saveState(t);
 726
 727         // Tear down the tab.
 728         dismissSubWindow(t);
 729         // Remove the WebView's settings from the BrowserSettings list of
 730         // observers.
 731         BrowserSettings.getInstance().deleteObserver(t.mMainView.getSettings());
 732         t.mMainView.destroy();
 733         t.mMainView = null;
 734     }
 735
 736     /**
 737      * Create a new subwindow unless a subwindow already exists.
 738      * @return True if a new subwindow was created. False if one already exists.
 739      */
 740     void createSubWindow() {
 741         Tab t = getTab(mCurrentTab);
 742         if (t != null && t.mSubView == null) {
 743             final View v = mInflateService.inflate(R.layout.browser_subwindow, null);
 744             final WebView w = (WebView) v.findViewById(R.id.webview);
 745             w.setMapTrackballToArrowKeys(false); // use trackball directly
 746             final SubWindowClient subClient =
 747                     new SubWindowClient(mActivity.getWebViewClient());
 748             final SubWindowChromeClient subChromeClient =
 749                     new SubWindowChromeClient(t,
 750                             mActivity.getWebChromeClient());
 751             w.setWebViewClient(subClient);
 752             w.setWebChromeClient(subChromeClient);
 753             w.setDownloadListener(mActivity);
 754             w.setOnCreateContextMenuListener(mActivity);
 755             final BrowserSettings s = BrowserSettings.getInstance();
 756             s.addObserver(w.getSettings()).update(s, null);
 757             t.mSubView = w;
 758             t.mSubViewClient = subClient;
 759             t.mSubViewChromeClient = subChromeClient;
 760             // FIXME: I really hate having to know the name of the view
 761             // containing the webview.
 762             t.mSubViewContainer = v.findViewById(R.id.subwindow_container);
 763             final ImageButton cancel =
 764                     (ImageButton) v.findViewById(R.id.subwindow_close);
 765             cancel.setOnClickListener(new OnClickListener() {
 766                     public void onClick(View v) {
 767                         subChromeClient.onCloseWindow(w);
 768                     }
 769                 });
 770         }
 771     }
 772
 773     /**
 774      * Show the tab that contains the given WebView.
 775      * @param view The WebView used to find the tab.
 776      */
 777     Tab getTabFromView(WebView view) {
 778         final int size = getTabCount();
 779         for (int i = 0; i < size; i++) {
 780             final Tab t = getTab(i);
 781             if (t.mSubView == view || t.mMainView == view) {
 782                 return t;
 783             }
 784         }
 785         return null;
 786     }
 787
 788     /**
 789      * Return the tab with the matching application id.
 790      * @param id The application identifier.
 791      */
 792     Tab getTabFromId(String id) {
 793         if (id == null) {
 794             return null;
 795         }
 796         final int size = getTabCount();
 797         for (int i = 0; i < size; i++) {
 798             final Tab t = getTab(i);
 799             if (id.equals(t.mAppId)) {
 800                 return t;
 801             }
 802         }
 803         return null;
 804     }
 805
 806     /**
 807      * Recreate the main WebView of the given tab. Returns true if the WebView
 808      * was deleted.
 809      */
 810     boolean recreateWebView(Tab t, String url) {
 811         final WebView w = t.mMainView;
 812         if (w != null) {
 813             if (url != null && url.equals(t.mOriginalUrl)) {
 814                 // The original url matches the current url. Just go back to the
 815                 // first history item so we can load it faster than if we
 816                 // rebuilt the WebView.
 817                 final WebBackForwardList list = w.copyBackForwardList();
 818                 if (list != null) {
 819                     w.goBackOrForward(-list.getCurrentIndex());
 820                     w.clearHistory(); // maintains the current page.
 821                     return false;
 822                 }
 823             }
 824             // Remove the settings object from the global settings and destroy
 825             // the WebView.
 826             BrowserSettings.getInstance().deleteObserver(
 827                     t.mMainView.getSettings());
 828             t.mMainView.destroy();
 829         }
 830         // Create a new WebView. If this tab is the current tab, we need to put
 831         // back all the clients so force it to be the current tab.
 832         t.mMainView = createNewWebView();
 833         if (getCurrentTab() == t) {
 834             setCurrentTab(t, true);
 835         }
 836         // Clear the saved state except for the app id and close-on-exit
 837         // values.
 838         t.mSavedState = null;
 839         t.mPickerData = null;
 840         // Save the new url in order to avoid deleting the WebView.
 841         t.mOriginalUrl = url;
 842         return true;
 843     }
 844
 845     /**
 846      * Creates a new WebView and registers it with the global settings.
 847      */
 848     private WebView createNewWebView() {
 849         // Create a new WebView
 850         WebView w = new WebView(mActivity);
 851         w.setMapTrackballToArrowKeys(false); // use trackball directly
 852         // Enable the built-in zoom
 853         w.getSettings().setBuiltInZoomControls(true);
 854         // Add this WebView to the settings observer list and update the
 855         // settings
 856         final BrowserSettings s = BrowserSettings.getInstance();
 857         s.addObserver(w.getSettings()).update(s, null);
 858         return w;
 859     }
 860
 861     /**
 862      * Put the current tab in the background and set newTab as the current tab.
 863      * @param newTab The new tab. If newTab is null, the current tab is not
 864      *               set.
 865      */
 866     boolean setCurrentTab(Tab newTab) {
 867         return setCurrentTab(newTab, false);
 868     }
 869
 870     /**
 871      * If force is true, this method skips the check for newTab == current.
 872      */
 873     private boolean setCurrentTab(Tab newTab, boolean force) {
 874         Tab current = getTab(mCurrentTab);
 875         if (current == newTab && !force) {
 876             return true;
 877         }
 878         if (current != null) {
 879             // Remove the current WebView and the container of the subwindow
 880             putTabInBackground(current);
 881         }
 882
 883         if (newTab == null) {
 884             return false;
 885         }
 886
 887         // Move the newTab to the end of the queue
 888         int index = mTabQueue.indexOf(newTab);
 889         if (index != -1) {
 890             mTabQueue.remove(index);
 891         }
 892         mTabQueue.add(newTab);
 893
 894         WebView mainView;
 895         WebView subView;
 896
 897         // Display the new current tab
 898         mCurrentTab = mTabs.indexOf(newTab);
 899         mainView = newTab.mMainView;
 900         boolean needRestore = (mainView == null);
 901         if (needRestore) {
 902             // Same work as in createNewTab() except don't do new Tab()
 903             newTab.mMainView = mainView = createNewWebView();
 904         }
 905         mainView.setWebViewClient(mActivity.getWebViewClient());
 906         mainView.setWebChromeClient(mActivity.getWebChromeClient());
 907         mainView.setOnCreateContextMenuListener(mActivity);
 908         mainView.setDownloadListener(mActivity);
 909         // Add the subwindow if it exists
 910         if (newTab.mSubViewContainer != null) {
 911             subView = newTab.mSubView;
 912             subView.setWebViewClient(newTab.mSubViewClient);
 913             subView.setWebChromeClient(newTab.mSubViewChromeClient);
 914             subView.setOnCreateContextMenuListener(mActivity);
 915             subView.setDownloadListener(mActivity);
 916         }
 917         if (needRestore) {
 918             // Have to finish setCurrentTab work before calling restoreState
 919             if (!restoreState(newTab.mSavedState, newTab)) {
 920                 mainView.loadUrl(BrowserSettings.getInstance().getHomePage());
 921             }
 922         }
 923         return true;
 924     }
 925
 926     /*
 927      * Put the tab in the background using all the empty/background clients.
 928      */
 929     private void putTabInBackground(Tab t) {
 930         WebView mainView = t.mMainView;
 931         // Set an empty callback so that default actions are not triggered.
 932         mainView.setWebViewClient(mEmptyClient);
 933         mainView.setWebChromeClient(mBackgroundChromeClient);
 934         mainView.setOnCreateContextMenuListener(null);
 935         // Leave the DownloadManager attached so that downloads can start in
 936         // a non-active window. This can happen when going to a site that does
 937         // a redirect after a period of time. The user could have switched to
 938         // another tab while waiting for the download to start.
 939         mainView.setDownloadListener(mActivity);
 940         WebView subView = t.mSubView;
 941         if (subView != null) {
 942             // Set an empty callback so that default actions are not triggered.
 943             subView.setWebViewClient(mEmptyClient);
 944             subView.setWebChromeClient(mBackgroundChromeClient);
 945             subView.setOnCreateContextMenuListener(null);
 946             subView.setDownloadListener(mActivity);
 947         }
 948     }
 949
 950     /*
 951      * Dismiss the subwindow for the given tab.
 952      */
 953     void dismissSubWindow(Tab t) {
 954         if (t != null && t.mSubView != null) {
 955             BrowserSettings.getInstance().deleteObserver(
 956                     t.mSubView.getSettings());
 957             t.mSubView.destroy();
 958             t.mSubView = null;
 959             t.mSubViewContainer = null;
 960         }
 961     }
 962
 963     /**
 964      * Ensure that Tab t has data to display in the tab picker.
 965      * @param  t   Tab to populate.
 966      */
 967     /* package */ void populatePickerData(Tab t) {
 968         if (t == null) {
 969             return;
 970         }
 971
 972         // mMainView == null indicates that the tab has been freed.
 973         if (t.mMainView == null) {
 974             populatePickerDataFromSavedState(t);
 975             return;
 976         }
 977
 978         // FIXME: The only place we cared about subwindow was for
 979         // bookmarking (i.e. not when saving state). Was this deliberate?
 980         final WebBackForwardList list = t.mMainView.copyBackForwardList();
 981         final WebHistoryItem item =
 982                 list != null ? list.getCurrentItem() : null;
 983         populatePickerData(t, item);
 984
 985         // This method is only called during the tab picker creation. At this
 986         // point we need to listen for new pictures since the WebView is still
 987         // active.
 988         final WebView w = t.getTopWindow();
 989         w.setPictureListener(t);
 990         // Capture the picture here instead of populatePickerData since it can
 991         // be called when saving the state of a tab.
 992         t.mPickerData.mPicture = w.capturePicture();
 993     }
 994
 995     // Create the PickerData and populate it using the saved state of the tab.
 996     private void populatePickerDataFromSavedState(Tab t) {
 997         if (t.mSavedState == null) {
 998             return;
 999         }
1000
1001         final PickerData data = new PickerData();
1002         final Bundle state = t.mSavedState;
1003         data.mUrl = state.getString(CURRURL);
1004         data.mTitle = state.getString(CURRTITLE);
1005         data.mWidth = state.getInt(CURRWIDTH, 0);
1006         // XXX: These keys are from WebView.savePicture so if they change, this
1007         // will break.
1008         data.mScale = state.getFloat("scale", 1.0f);
1009         data.mScrollX = state.getInt("scrollX", 0);
1010         data.mScrollY = state.getInt("scrollY", 0);
1011
1012         if (state.containsKey(CURRPICTURE)) {
1013             final File f = new File(t.mSavedState.getString(CURRPICTURE));
1014             try {
1015                 final FileInputStream in = new FileInputStream(f);
1016                 data.mPicture = Picture.createFromStream(in);
1017                 in.close();
1018             } catch (Exception ex) {
1019                 // Ignore any problems with inflating the picture. We just
1020                 // won't draw anything.
1021             }
1022         }
1023
1024         // Set the tab's picker data.
1025         t.mPickerData = data;
1026     }
1027
1028     // Populate the picker data using the given history item and the current
1029     // top WebView.
1030     private void populatePickerData(Tab t, WebHistoryItem item) {
1031         final PickerData data = new PickerData();
1032         if (item != null) {
1033             data.mUrl = item.getUrl();
1034             data.mTitle = item.getTitle();
1035             if (data.mTitle == null) {
1036                 data.mTitle = data.mUrl;
1037             }
1038         }
1039         // We want to display the top window in the tab picker but use the url
1040         // and title of the main window.
1041         final WebView w = t.getTopWindow();
1042         data.mWidth = w.getWidth();
1043         data.mScale = w.getScale();
1044         data.mScrollX = w.getScrollX();
1045         data.mScrollY = w.getScrollY();
1046         t.mPickerData = data;
1047     }
1048
1049     /**
1050      * Clean up the data for all tabs.
1051      */
1052     /* package */ void wipeAllPickerData() {
1053         int size = getTabCount();
1054         for (int i = 0; i < size; i++) {
1055             final Tab t = getTab(i);
1056             if (t != null && t.mSavedState == null) {
1057                 t.mPickerData = null;
1058             }
1059             if (t.mMainView != null) {
1060                 // Clear the picture listeners.
1061                 t.mMainView.setPictureListener(null);
1062                 if (t.mSubView != null) {
1063                     t.mSubView.setPictureListener(null);
1064                 }
1065             }
1066         }
1067     }
1068
1069     /*
1070      * Save the state for an individual tab.
1071      */
1072     private boolean saveState(Tab t) {
1073         if (t != null) {
1074             final WebView w = t.mMainView;
1075             // If the WebView is null it means we ran low on memory and we
1076             // already stored the saved state in mSavedState.
1077             if (w == null) {
1078                 return true;
1079             }
1080             final Bundle b = new Bundle();
1081             final WebBackForwardList list = w.saveState(b);
1082             if (list != null) {
1083                 final File f = new File(mThumbnailDir, w.hashCode()
1084                         + "_pic.save");
1085                 if (w.savePicture(b, f)) {
1086                     b.putString(CURRPICTURE, f.getPath());
1087                 }
1088             }
1089
1090             // Store some extra info for displaying the tab in the picker.
1091             final WebHistoryItem item =
1092                     list != null ? list.getCurrentItem() : null;
1093             populatePickerData(t, item);
1094
1095             // XXX: WebView.savePicture stores the scale and scroll positions
1096             // in the bundle so we don't have to do it here.
1097             final PickerData data = t.mPickerData;
1098             if (data.mUrl != null) {
1099                 b.putString(CURRURL, data.mUrl);
1100             }
1101             if (data.mTitle != null) {
1102                 b.putString(CURRTITLE, data.mTitle);
1103             }
1104             b.putInt(CURRWIDTH, data.mWidth);
1105             b.putBoolean(CLOSEONEXIT, t.mCloseOnExit);
1106             if (t.mAppId != null) {
1107                 b.putString(APPID, t.mAppId);
1108             }
1109             if (t.mOriginalUrl != null) {
1110                 b.putString(ORIGINALURL, t.mOriginalUrl);
1111             }
1112
1113             // Remember the parent tab so the relationship can be restored.
1114             if (t.mParentTab != null) {
1115                 b.putInt(PARENTTAB, getTabIndex(t.mParentTab));
1116             }
1117
1118             // Remember the saved state.
1119             t.mSavedState = b;
1120             return true;
1121         }
1122         return false;
1123     }
1124
1125     /*
1126      * Restore the state of the tab.
1127      */
1128     private boolean restoreState(Bundle b, Tab t) {
1129         if (b == null) {
1130             return false;
1131         }
1132         // Restore the internal state even if the WebView fails to restore.
1133         // This will maintain the app id, original url and close-on-exit values.
1134         t.mSavedState = null;
1135         t.mPickerData = null;
1136         t.mCloseOnExit = b.getBoolean(CLOSEONEXIT);
1137         t.mAppId = b.getString(APPID);
1138         t.mOriginalUrl = b.getString(ORIGINALURL);
1139
1140         final WebView w = t.mMainView;
1141         final WebBackForwardList list = w.restoreState(b);
1142         if (list == null) {
1143             return false;
1144         }
1145         if (b.containsKey(CURRPICTURE)) {
1146             final File f = new File(b.getString(CURRPICTURE));
1147             w.restorePicture(b, f);
1148             f.delete();
1149         }
1150         return true;
1151     }
1152 }