blob: 02276215c38b2bd90636c09871547eb5599f7ae0 [file] [log] [blame]
Michael Kolb8233fac2010-10-26 16:08:53 -07001/*
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 com.android.browser.IntentHandler.UrlData;
20import com.android.browser.search.SearchEngine;
21import com.android.common.Search;
22
23import android.app.Activity;
24import android.app.DownloadManager;
25import android.app.SearchManager;
26import android.content.ClipboardManager;
27import android.content.ContentProvider;
28import android.content.ContentProviderClient;
29import android.content.ContentResolver;
30import android.content.ContentValues;
31import android.content.Context;
32import android.content.Intent;
33import android.content.pm.PackageManager;
34import android.content.pm.ResolveInfo;
35import android.content.res.Configuration;
Leon Scroggins1961ed22010-12-07 15:22:21 -050036import android.database.ContentObserver;
Michael Kolb8233fac2010-10-26 16:08:53 -070037import android.database.Cursor;
38import android.database.sqlite.SQLiteDatabase;
39import android.database.sqlite.SQLiteException;
40import android.graphics.Bitmap;
41import android.graphics.Canvas;
42import android.graphics.Picture;
43import android.net.Uri;
44import android.net.http.SslError;
45import android.os.AsyncTask;
46import android.os.Bundle;
47import android.os.Handler;
48import android.os.Message;
49import android.os.PowerManager;
50import android.os.PowerManager.WakeLock;
Ben Murdoch8029a772010-11-16 11:58:21 +000051import android.preference.PreferenceActivity;
Michael Kolb8233fac2010-10-26 16:08:53 -070052import android.provider.Browser;
53import android.provider.BrowserContract;
54import android.provider.BrowserContract.History;
55import android.provider.BrowserContract.Images;
56import android.provider.ContactsContract;
57import android.provider.ContactsContract.Intents.Insert;
58import android.speech.RecognizerResultsIntent;
59import android.text.TextUtils;
60import android.util.Log;
61import android.view.ActionMode;
62import android.view.ContextMenu;
63import android.view.ContextMenu.ContextMenuInfo;
64import android.view.Gravity;
65import android.view.KeyEvent;
66import android.view.LayoutInflater;
67import android.view.Menu;
68import android.view.MenuInflater;
69import android.view.MenuItem;
70import android.view.MenuItem.OnMenuItemClickListener;
71import android.view.View;
72import android.webkit.CookieManager;
73import android.webkit.CookieSyncManager;
74import android.webkit.HttpAuthHandler;
75import android.webkit.SslErrorHandler;
76import android.webkit.ValueCallback;
77import android.webkit.WebChromeClient;
78import android.webkit.WebIconDatabase;
79import android.webkit.WebSettings;
80import android.webkit.WebView;
81import android.widget.TextView;
82
83import java.io.ByteArrayOutputStream;
84import java.io.File;
85import java.net.URLEncoder;
86import java.util.Calendar;
87import java.util.HashMap;
Michael Kolb1bf23132010-11-19 12:55:12 -080088import java.util.List;
Michael Kolb8233fac2010-10-26 16:08:53 -070089
90/**
91 * Controller for browser
92 */
93public class Controller
94 implements WebViewController, UiController {
95
96 private static final String LOGTAG = "Controller";
97
98 // public message ids
99 public final static int LOAD_URL = 1001;
100 public final static int STOP_LOAD = 1002;
101
102 // Message Ids
103 private static final int FOCUS_NODE_HREF = 102;
104 private static final int RELEASE_WAKELOCK = 107;
105
106 static final int UPDATE_BOOKMARK_THUMBNAIL = 108;
107
108 private static final int OPEN_BOOKMARKS = 201;
109
110 private static final int EMPTY_MENU = -1;
111
Michael Kolb8233fac2010-10-26 16:08:53 -0700112 // activity requestCode
113 final static int PREFERENCES_PAGE = 3;
114 final static int FILE_SELECTED = 4;
Ben Murdoch8029a772010-11-16 11:58:21 +0000115 final static int AUTOFILL_SETUP = 5;
116
Michael Kolb8233fac2010-10-26 16:08:53 -0700117 private final static int WAKELOCK_TIMEOUT = 5 * 60 * 1000; // 5 minutes
118
119 // As the ids are dynamically created, we can't guarantee that they will
120 // be in sequence, so this static array maps ids to a window number.
121 final static private int[] WINDOW_SHORTCUT_ID_ARRAY =
122 { R.id.window_one_menu_id, R.id.window_two_menu_id,
123 R.id.window_three_menu_id, R.id.window_four_menu_id,
124 R.id.window_five_menu_id, R.id.window_six_menu_id,
125 R.id.window_seven_menu_id, R.id.window_eight_menu_id };
126
127 // "source" parameter for Google search through search key
128 final static String GOOGLE_SEARCH_SOURCE_SEARCHKEY = "browser-key";
129 // "source" parameter for Google search through simplily type
130 final static String GOOGLE_SEARCH_SOURCE_TYPE = "browser-type";
131
132 private Activity mActivity;
133 private UI mUi;
134 private TabControl mTabControl;
135 private BrowserSettings mSettings;
136 private WebViewFactory mFactory;
137
138 private WakeLock mWakeLock;
139
140 private UrlHandler mUrlHandler;
141 private UploadHandler mUploadHandler;
142 private IntentHandler mIntentHandler;
Michael Kolb8233fac2010-10-26 16:08:53 -0700143 private PageDialogsHandler mPageDialogsHandler;
144 private NetworkStateHandler mNetworkHandler;
145
Ben Murdoch8029a772010-11-16 11:58:21 +0000146 private Message mAutoFillSetupMessage;
147
Michael Kolb8233fac2010-10-26 16:08:53 -0700148 private boolean mShouldShowErrorConsole;
149
150 private SystemAllowGeolocationOrigins mSystemAllowGeolocationOrigins;
151
152 // FIXME, temp address onPrepareMenu performance problem.
153 // When we move everything out of view, we should rewrite this.
154 private int mCurrentMenuState = 0;
155 private int mMenuState = R.id.MAIN_MENU;
156 private int mOldMenuState = EMPTY_MENU;
157 private Menu mCachedMenu;
158
159 // Used to prevent chording to result in firing two shortcuts immediately
160 // one after another. Fixes bug 1211714.
161 boolean mCanChord;
162 private boolean mMenuIsDown;
163
164 // For select and find, we keep track of the ActionMode so that
165 // finish() can be called as desired.
166 private ActionMode mActionMode;
167
168 /**
169 * Only meaningful when mOptionsMenuOpen is true. This variable keeps track
170 * of whether the configuration has changed. The first onMenuOpened call
171 * after a configuration change is simply a reopening of the same menu
172 * (i.e. mIconView did not change).
173 */
174 private boolean mConfigChanged;
175
176 /**
177 * Keeps track of whether the options menu is open. This is important in
178 * determining whether to show or hide the title bar overlay
179 */
180 private boolean mOptionsMenuOpen;
181
182 /**
183 * Whether or not the options menu is in its bigger, popup menu form. When
184 * true, we want the title bar overlay to be gone. When false, we do not.
185 * Only meaningful if mOptionsMenuOpen is true.
186 */
187 private boolean mExtendedMenuOpen;
188
189 private boolean mInLoad;
190
191 private boolean mActivityPaused = true;
192 private boolean mLoadStopped;
193
194 private Handler mHandler;
Leon Scroggins1961ed22010-12-07 15:22:21 -0500195 // Checks to see when the bookmarks database has changed, and updates the
196 // Tabs' notion of whether they represent bookmarked sites.
197 private ContentObserver mBookmarksObserver;
John Reck0ebd3ac2010-12-09 11:14:04 -0800198 private DataController mDataController;
Michael Kolb8233fac2010-10-26 16:08:53 -0700199
200 private static class ClearThumbnails extends AsyncTask<File, Void, Void> {
201 @Override
202 public Void doInBackground(File... files) {
203 if (files != null) {
204 for (File f : files) {
205 if (!f.delete()) {
206 Log.e(LOGTAG, f.getPath() + " was not deleted");
207 }
208 }
209 }
210 return null;
211 }
212 }
213
214 public Controller(Activity browser) {
215 mActivity = browser;
216 mSettings = BrowserSettings.getInstance();
John Reck0ebd3ac2010-12-09 11:14:04 -0800217 mDataController = DataController.getInstance(mActivity);
Michael Kolb8233fac2010-10-26 16:08:53 -0700218 mTabControl = new TabControl(this);
219 mSettings.setController(this);
220
221 mUrlHandler = new UrlHandler(this);
222 mIntentHandler = new IntentHandler(mActivity, this);
Michael Kolb8233fac2010-10-26 16:08:53 -0700223 mPageDialogsHandler = new PageDialogsHandler(mActivity, this);
224
225 PowerManager pm = (PowerManager) mActivity
226 .getSystemService(Context.POWER_SERVICE);
227 mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "Browser");
228
229 startHandler();
Leon Scroggins1961ed22010-12-07 15:22:21 -0500230 mBookmarksObserver = new ContentObserver(mHandler) {
231 @Override
232 public void onChange(boolean selfChange) {
233 int size = mTabControl.getTabCount();
234 for (int i = 0; i < size; i++) {
235 mTabControl.getTab(i).updateBookmarkedStatus();
236 }
237 }
238
239 };
240 browser.getContentResolver().registerContentObserver(
241 BrowserContract.Bookmarks.CONTENT_URI, true, mBookmarksObserver);
Michael Kolb8233fac2010-10-26 16:08:53 -0700242
243 mNetworkHandler = new NetworkStateHandler(mActivity, this);
244 // Start watching the default geolocation permissions
245 mSystemAllowGeolocationOrigins =
246 new SystemAllowGeolocationOrigins(mActivity.getApplicationContext());
247 mSystemAllowGeolocationOrigins.start();
248
249 retainIconsOnStartup();
250 }
251
252 void start(Bundle icicle, Intent intent) {
253 // Unless the last browser usage was within 24 hours, destroy any
254 // remaining incognito tabs.
255
256 Calendar lastActiveDate = icicle != null ?
257 (Calendar) icicle.getSerializable("lastActiveDate") : null;
258 Calendar today = Calendar.getInstance();
259 Calendar yesterday = Calendar.getInstance();
260 yesterday.add(Calendar.DATE, -1);
261
Michael Kolb1bf23132010-11-19 12:55:12 -0800262 boolean restoreIncognitoTabs = !(lastActiveDate == null
Michael Kolb8233fac2010-10-26 16:08:53 -0700263 || lastActiveDate.before(yesterday)
Michael Kolb1bf23132010-11-19 12:55:12 -0800264 || lastActiveDate.after(today));
Michael Kolb8233fac2010-10-26 16:08:53 -0700265
Michael Kolb1bf23132010-11-19 12:55:12 -0800266 if (!mTabControl.restoreState(icicle, restoreIncognitoTabs,
267 mUi.needsRestoreAllTabs())) {
Michael Kolb8233fac2010-10-26 16:08:53 -0700268 // there is no quit on Android. But if we can't restore the state,
269 // we can treat it as a new Browser, remove the old session cookies.
Kristian Monsen3a4e8092010-12-08 11:09:25 +0000270 // This is done async in the CookieManager.
271 CookieManager.getInstance().removeSessionCookie();
Kristian Monsen2cd97012010-12-07 11:11:40 +0000272
Michael Kolb8233fac2010-10-26 16:08:53 -0700273 // remove any incognito files
Steve Block83101a82010-11-26 11:33:35 +0000274 WebView.cleanupPrivateBrowsingFiles();
Michael Kolb8233fac2010-10-26 16:08:53 -0700275 final Bundle extra = intent.getExtras();
276 // Create an initial tab.
277 // If the intent is ACTION_VIEW and data is not null, the Browser is
278 // invoked to view the content by another application. In this case,
279 // the tab will be close when exit.
280 UrlData urlData = mIntentHandler.getUrlDataFromIntent(intent);
281
282 String action = intent.getAction();
283 final Tab t = mTabControl.createNewTab(
284 (Intent.ACTION_VIEW.equals(action) &&
285 intent.getData() != null)
286 || RecognizerResultsIntent.ACTION_VOICE_SEARCH_RESULTS
287 .equals(action),
288 intent.getStringExtra(Browser.EXTRA_APPLICATION_ID),
289 urlData.mUrl, false);
290 addTab(t);
291 setActiveTab(t);
292 WebView webView = t.getWebView();
293 if (extra != null) {
294 int scale = extra.getInt(Browser.INITIAL_ZOOM_LEVEL, 0);
295 if (scale > 0 && scale <= 1000) {
296 webView.setInitialScale(scale);
297 }
298 }
299
300 if (urlData.isEmpty()) {
301 loadUrl(webView, mSettings.getHomePage());
302 } else {
303 loadUrlDataIn(t, urlData);
304 }
305 } else {
Michael Kolb1bf23132010-11-19 12:55:12 -0800306 mUi.updateTabs(mTabControl.getTabs());
307 if (!restoreIncognitoTabs) {
Steve Block83101a82010-11-26 11:33:35 +0000308 WebView.cleanupPrivateBrowsingFiles();
Michael Kolb8233fac2010-10-26 16:08:53 -0700309 }
310 // TabControl.restoreState() will create a new tab even if
311 // restoring the state fails.
312 setActiveTab(mTabControl.getCurrentTab());
313 }
314 // clear up the thumbnail directory, which is no longer used;
315 // ideally this should only be run once after an upgrade from
316 // a previous version of the browser
317 new ClearThumbnails().execute(mTabControl.getThumbnailDir()
318 .listFiles());
319 // Read JavaScript flags if it exists.
320 String jsFlags = getSettings().getJsFlags();
321 if (jsFlags.trim().length() != 0) {
322 getCurrentWebView().setJsFlags(jsFlags);
323 }
324 }
325
326 void setWebViewFactory(WebViewFactory factory) {
327 mFactory = factory;
328 }
329
Michael Kolb1514bb72010-11-22 09:11:48 -0800330 @Override
331 public WebViewFactory getWebViewFactory() {
Michael Kolb8233fac2010-10-26 16:08:53 -0700332 return mFactory;
333 }
334
335 @Override
Michael Kolba713ec82010-11-29 17:27:06 -0800336 public void onSetWebView(Tab tab, WebView view) {
337 mUi.onSetWebView(tab, view);
338 }
339
340 @Override
Michael Kolb1514bb72010-11-22 09:11:48 -0800341 public void createSubWindow(Tab tab) {
342 endActionMode();
343 WebView mainView = tab.getWebView();
344 WebView subView = mFactory.createWebView((mainView == null)
345 ? false
346 : mainView.isPrivateBrowsingEnabled());
347 mUi.createSubWindow(tab, subView);
348 }
349
350 @Override
Michael Kolb8233fac2010-10-26 16:08:53 -0700351 public Activity getActivity() {
352 return mActivity;
353 }
354
355 void setUi(UI ui) {
356 mUi = ui;
357 }
358
359 BrowserSettings getSettings() {
360 return mSettings;
361 }
362
363 IntentHandler getIntentHandler() {
364 return mIntentHandler;
365 }
366
367 @Override
368 public UI getUi() {
369 return mUi;
370 }
371
372 int getMaxTabs() {
373 return mActivity.getResources().getInteger(R.integer.max_tabs);
374 }
375
376 @Override
377 public TabControl getTabControl() {
378 return mTabControl;
379 }
380
Michael Kolb1bf23132010-11-19 12:55:12 -0800381 @Override
382 public List<Tab> getTabs() {
383 return mTabControl.getTabs();
384 }
385
Michael Kolb8233fac2010-10-26 16:08:53 -0700386 // Open the icon database and retain all the icons for visited sites.
Ben Murdoch9446b932010-11-25 16:20:14 +0000387 // This is done on a background thread so as not to stall startup.
Michael Kolb8233fac2010-10-26 16:08:53 -0700388 private void retainIconsOnStartup() {
Ben Murdoch9446b932010-11-25 16:20:14 +0000389 // WebIconDatabase needs to be retrieved on the UI thread so that if
390 // it has not been created successfully yet the Handler is started on the
391 // UI thread.
392 new RetainIconsOnStartupTask(WebIconDatabase.getInstance()).execute();
393 }
394
395 private class RetainIconsOnStartupTask extends AsyncTask<Void, Void, Void> {
396 private WebIconDatabase mDb;
397
398 public RetainIconsOnStartupTask(WebIconDatabase db) {
399 mDb = db;
400 }
401
402 protected Void doInBackground(Void... unused) {
403 mDb.open(mActivity.getDir("icons", 0).getPath());
404 Cursor c = null;
405 try {
406 c = Browser.getAllBookmarks(mActivity.getContentResolver());
407 if (c.moveToFirst()) {
408 int urlIndex = c.getColumnIndex(Browser.BookmarkColumns.URL);
409 do {
410 String url = c.getString(urlIndex);
411 mDb.retainIconForPageUrl(url);
412 } while (c.moveToNext());
413 }
414 } catch (IllegalStateException e) {
415 Log.e(LOGTAG, "retainIconsOnStartup", e);
416 } finally {
417 if (c != null) c.close();
Michael Kolb8233fac2010-10-26 16:08:53 -0700418 }
Ben Murdoch9446b932010-11-25 16:20:14 +0000419
420 return null;
Michael Kolb8233fac2010-10-26 16:08:53 -0700421 }
422 }
423
424 private void startHandler() {
425 mHandler = new Handler() {
426
427 @Override
428 public void handleMessage(Message msg) {
429 switch (msg.what) {
430 case OPEN_BOOKMARKS:
431 bookmarksOrHistoryPicker(false);
432 break;
433 case FOCUS_NODE_HREF:
434 {
435 String url = (String) msg.getData().get("url");
436 String title = (String) msg.getData().get("title");
437 if (TextUtils.isEmpty(url)) {
438 break;
439 }
440 HashMap focusNodeMap = (HashMap) msg.obj;
441 WebView view = (WebView) focusNodeMap.get("webview");
442 // Only apply the action if the top window did not change.
443 if (getCurrentTopWebView() != view) {
444 break;
445 }
446 switch (msg.arg1) {
447 case R.id.open_context_menu_id:
448 case R.id.view_image_context_menu_id:
449 loadUrlFromContext(getCurrentTopWebView(), url);
450 break;
Leon Scroggins026f2542010-11-22 13:26:12 -0500451 case R.id.open_newtab_context_menu_id:
452 final Tab parent = mTabControl.getCurrentTab();
453 final Tab newTab = openTab(url, false);
454 if (newTab != null && newTab != parent) {
455 parent.addChildTab(newTab);
456 }
457 break;
Michael Kolb8233fac2010-10-26 16:08:53 -0700458 case R.id.bookmark_context_menu_id:
459 Intent intent = new Intent(mActivity,
460 AddBookmarkPage.class);
461 intent.putExtra(BrowserContract.Bookmarks.URL, url);
462 intent.putExtra(BrowserContract.Bookmarks.TITLE,
463 title);
464 mActivity.startActivity(intent);
465 break;
466 case R.id.share_link_context_menu_id:
467 sharePage(mActivity, title, url, null,
468 null);
469 break;
470 case R.id.copy_link_context_menu_id:
471 copy(url);
472 break;
473 case R.id.save_link_context_menu_id:
474 case R.id.download_context_menu_id:
Leon Scroggins63c02662010-11-18 15:16:27 -0500475 DownloadHandler.onDownloadStartNoStream(
476 mActivity, url, null, null, null);
Michael Kolb8233fac2010-10-26 16:08:53 -0700477 break;
478 }
479 break;
480 }
481
482 case LOAD_URL:
483 loadUrlFromContext(getCurrentTopWebView(), (String) msg.obj);
484 break;
485
486 case STOP_LOAD:
487 stopLoading();
488 break;
489
490 case RELEASE_WAKELOCK:
491 if (mWakeLock.isHeld()) {
492 mWakeLock.release();
493 // if we reach here, Browser should be still in the
494 // background loading after WAKELOCK_TIMEOUT (5-min).
495 // To avoid burning the battery, stop loading.
496 mTabControl.stopAllLoading();
497 }
498 break;
499
500 case UPDATE_BOOKMARK_THUMBNAIL:
501 WebView view = (WebView) msg.obj;
502 if (view != null) {
503 updateScreenshot(view);
504 }
505 break;
506 }
507 }
508 };
509
510 }
511
Michael Kolbba99c5d2010-11-29 14:57:41 -0800512 @Override
513 public void shareCurrentPage() {
514 shareCurrentPage(mTabControl.getCurrentTab());
515 }
516
517 private void shareCurrentPage(Tab tab) {
518 if (tab != null) {
519 tab.populatePickerData();
520 sharePage(mActivity, tab.getTitle(),
521 tab.getUrl(), tab.getFavicon(),
522 createScreenshot(tab.getWebView(),
523 getDesiredThumbnailWidth(mActivity),
524 getDesiredThumbnailHeight(mActivity)));
525 }
526 }
527
Michael Kolb8233fac2010-10-26 16:08:53 -0700528 /**
529 * Share a page, providing the title, url, favicon, and a screenshot. Uses
530 * an {@link Intent} to launch the Activity chooser.
531 * @param c Context used to launch a new Activity.
532 * @param title Title of the page. Stored in the Intent with
533 * {@link Intent#EXTRA_SUBJECT}
534 * @param url URL of the page. Stored in the Intent with
535 * {@link Intent#EXTRA_TEXT}
536 * @param favicon Bitmap of the favicon for the page. Stored in the Intent
537 * with {@link Browser#EXTRA_SHARE_FAVICON}
538 * @param screenshot Bitmap of a screenshot of the page. Stored in the
539 * Intent with {@link Browser#EXTRA_SHARE_SCREENSHOT}
540 */
541 static final void sharePage(Context c, String title, String url,
542 Bitmap favicon, Bitmap screenshot) {
543 Intent send = new Intent(Intent.ACTION_SEND);
544 send.setType("text/plain");
545 send.putExtra(Intent.EXTRA_TEXT, url);
546 send.putExtra(Intent.EXTRA_SUBJECT, title);
547 send.putExtra(Browser.EXTRA_SHARE_FAVICON, favicon);
548 send.putExtra(Browser.EXTRA_SHARE_SCREENSHOT, screenshot);
549 try {
550 c.startActivity(Intent.createChooser(send, c.getString(
551 R.string.choosertitle_sharevia)));
552 } catch(android.content.ActivityNotFoundException ex) {
553 // if no app handles it, do nothing
554 }
555 }
556
557 private void copy(CharSequence text) {
558 ClipboardManager cm = (ClipboardManager) mActivity
559 .getSystemService(Context.CLIPBOARD_SERVICE);
560 cm.setText(text);
561 }
562
563 // lifecycle
564
565 protected void onConfgurationChanged(Configuration config) {
566 mConfigChanged = true;
567 if (mPageDialogsHandler != null) {
568 mPageDialogsHandler.onConfigurationChanged(config);
569 }
570 mUi.onConfigurationChanged(config);
571 }
572
573 @Override
574 public void handleNewIntent(Intent intent) {
575 mIntentHandler.onNewIntent(intent);
576 }
577
578 protected void onPause() {
579 if (mActivityPaused) {
580 Log.e(LOGTAG, "BrowserActivity is already paused.");
581 return;
582 }
Michael Kolb8233fac2010-10-26 16:08:53 -0700583 mActivityPaused = true;
Michael Kolb70976932010-11-30 11:34:01 -0800584 Tab tab = mTabControl.getCurrentTab();
585 if (tab != null) {
586 tab.pause();
587 if (!pauseWebViewTimers(tab)) {
588 mWakeLock.acquire();
589 mHandler.sendMessageDelayed(mHandler
590 .obtainMessage(RELEASE_WAKELOCK), WAKELOCK_TIMEOUT);
591 }
Michael Kolb8233fac2010-10-26 16:08:53 -0700592 }
593 mUi.onPause();
594 mNetworkHandler.onPause();
595
596 WebView.disablePlatformNotifications();
597 }
598
599 void onSaveInstanceState(Bundle outState) {
600 // the default implementation requires each view to have an id. As the
601 // browser handles the state itself and it doesn't use id for the views,
602 // don't call the default implementation. Otherwise it will trigger the
603 // warning like this, "couldn't save which view has focus because the
604 // focused view XXX has no id".
605
606 // Save all the tabs
607 mTabControl.saveState(outState);
608 // Save time so that we know how old incognito tabs (if any) are.
609 outState.putSerializable("lastActiveDate", Calendar.getInstance());
610 }
611
612 void onResume() {
613 if (!mActivityPaused) {
614 Log.e(LOGTAG, "BrowserActivity is already resumed.");
615 return;
616 }
Michael Kolb8233fac2010-10-26 16:08:53 -0700617 mActivityPaused = false;
Michael Kolb70976932010-11-30 11:34:01 -0800618 Tab current = mTabControl.getCurrentTab();
619 if (current != null) {
620 current.resume();
621 resumeWebViewTimers(current);
622 }
Michael Kolb8233fac2010-10-26 16:08:53 -0700623 if (mWakeLock.isHeld()) {
624 mHandler.removeMessages(RELEASE_WAKELOCK);
625 mWakeLock.release();
626 }
627 mUi.onResume();
628 mNetworkHandler.onResume();
629 WebView.enablePlatformNotifications();
630 }
631
Michael Kolb70976932010-11-30 11:34:01 -0800632 /**
Michael Kolbba99c5d2010-11-29 14:57:41 -0800633 * resume all WebView timers using the WebView instance of the given tab
Michael Kolb70976932010-11-30 11:34:01 -0800634 * @param tab guaranteed non-null
635 */
636 private void resumeWebViewTimers(Tab tab) {
Michael Kolb8233fac2010-10-26 16:08:53 -0700637 boolean inLoad = tab.inPageLoad();
638 if ((!mActivityPaused && !inLoad) || (mActivityPaused && inLoad)) {
639 CookieSyncManager.getInstance().startSync();
640 WebView w = tab.getWebView();
641 if (w != null) {
642 w.resumeTimers();
643 }
644 }
645 }
646
Michael Kolb70976932010-11-30 11:34:01 -0800647 /**
648 * Pause all WebView timers using the WebView of the given tab
649 * @param tab
650 * @return true if the timers are paused or tab is null
651 */
652 private boolean pauseWebViewTimers(Tab tab) {
653 if (tab == null) {
654 return true;
655 } else if (!tab.inPageLoad()) {
Michael Kolb8233fac2010-10-26 16:08:53 -0700656 CookieSyncManager.getInstance().stopSync();
657 WebView w = getCurrentWebView();
658 if (w != null) {
659 w.pauseTimers();
660 }
661 return true;
Michael Kolb8233fac2010-10-26 16:08:53 -0700662 }
Michael Kolb70976932010-11-30 11:34:01 -0800663 return false;
Michael Kolb8233fac2010-10-26 16:08:53 -0700664 }
665
666 void onDestroy() {
667 if (mUploadHandler != null) {
668 mUploadHandler.onResult(Activity.RESULT_CANCELED, null);
669 mUploadHandler = null;
670 }
671 if (mTabControl == null) return;
672 mUi.onDestroy();
673 // Remove the current tab and sub window
674 Tab t = mTabControl.getCurrentTab();
675 if (t != null) {
676 dismissSubWindow(t);
677 removeTab(t);
678 }
Leon Scroggins1961ed22010-12-07 15:22:21 -0500679 mActivity.getContentResolver().unregisterContentObserver(mBookmarksObserver);
Michael Kolb8233fac2010-10-26 16:08:53 -0700680 // Destroy all the tabs
681 mTabControl.destroy();
682 WebIconDatabase.getInstance().close();
683 // Stop watching the default geolocation permissions
684 mSystemAllowGeolocationOrigins.stop();
685 mSystemAllowGeolocationOrigins = null;
686 }
687
688 protected boolean isActivityPaused() {
689 return mActivityPaused;
690 }
691
692 protected void onLowMemory() {
693 mTabControl.freeMemory();
694 }
695
696 @Override
697 public boolean shouldShowErrorConsole() {
698 return mShouldShowErrorConsole;
699 }
700
701 protected void setShouldShowErrorConsole(boolean show) {
702 if (show == mShouldShowErrorConsole) {
703 // Nothing to do.
704 return;
705 }
706 mShouldShowErrorConsole = show;
707 Tab t = mTabControl.getCurrentTab();
708 if (t == null) {
709 // There is no current tab so we cannot toggle the error console
710 return;
711 }
712 mUi.setShouldShowErrorConsole(t, show);
713 }
714
715 @Override
716 public void stopLoading() {
717 mLoadStopped = true;
718 Tab tab = mTabControl.getCurrentTab();
719 resetTitleAndRevertLockIcon(tab);
720 WebView w = getCurrentTopWebView();
721 w.stopLoading();
722 // FIXME: before refactor, it is using mWebViewClient. So I keep the
723 // same logic here. But for subwindow case, should we call into the main
724 // WebView's onPageFinished as we never call its onPageStarted and if
725 // the page finishes itself, we don't call onPageFinished.
726 mTabControl.getCurrentWebView().getWebViewClient().onPageFinished(w,
727 w.getUrl());
728 mUi.onPageStopped(tab);
729 }
730
731 boolean didUserStopLoading() {
732 return mLoadStopped;
733 }
734
735 // WebViewController
736
737 @Override
738 public void onPageStarted(Tab tab, WebView view, String url, Bitmap favicon) {
739
740 // We've started to load a new page. If there was a pending message
741 // to save a screenshot then we will now take the new page and save
742 // an incorrect screenshot. Therefore, remove any pending thumbnail
743 // messages from the queue.
744 mHandler.removeMessages(Controller.UPDATE_BOOKMARK_THUMBNAIL,
745 view);
746
747 // reset sync timer to avoid sync starts during loading a page
748 CookieSyncManager.getInstance().resetSync();
749
750 if (!mNetworkHandler.isNetworkUp()) {
751 view.setNetworkAvailable(false);
752 }
753
754 // when BrowserActivity just starts, onPageStarted may be called before
755 // onResume as it is triggered from onCreate. Call resumeWebViewTimers
756 // to start the timer. As we won't switch tabs while an activity is in
757 // pause state, we can ensure calling resume and pause in pair.
758 if (mActivityPaused) {
Michael Kolb70976932010-11-30 11:34:01 -0800759 resumeWebViewTimers(tab);
Michael Kolb8233fac2010-10-26 16:08:53 -0700760 }
761 mLoadStopped = false;
762 if (!mNetworkHandler.isNetworkUp()) {
763 mNetworkHandler.createAndShowNetworkDialog();
764 }
765 endActionMode();
766
767 mUi.onPageStarted(tab, url, favicon);
768
Michael Kolb8233fac2010-10-26 16:08:53 -0700769 // update the bookmark database for favicon
770 maybeUpdateFavicon(tab, null, url, favicon);
771
772 Performance.tracePageStart(url);
773
774 // Performance probe
775 if (false) {
776 Performance.onPageStarted();
777 }
778
779 }
780
781 @Override
782 public void onPageFinished(Tab tab, String url) {
783 mUi.onPageFinished(tab, url);
784 if (!tab.isPrivateBrowsingEnabled()) {
785 if (tab.inForeground() && !didUserStopLoading()
786 || !tab.inForeground()) {
787 // Only update the bookmark screenshot if the user did not
788 // cancel the load early.
789 mHandler.sendMessageDelayed(mHandler.obtainMessage(
790 UPDATE_BOOKMARK_THUMBNAIL, 0, 0, tab.getWebView()),
791 500);
792 }
793 }
794 // pause the WebView timer and release the wake lock if it is finished
795 // while BrowserActivity is in pause state.
Michael Kolb70976932010-11-30 11:34:01 -0800796 if (mActivityPaused && pauseWebViewTimers(tab)) {
Michael Kolb8233fac2010-10-26 16:08:53 -0700797 if (mWakeLock.isHeld()) {
798 mHandler.removeMessages(RELEASE_WAKELOCK);
799 mWakeLock.release();
800 }
801 }
802 // Performance probe
803 if (false) {
804 Performance.onPageFinished(url);
805 }
806
807 Performance.tracePageFinished();
808 }
809
810 @Override
811 public void onProgressChanged(Tab tab, int newProgress) {
812
813 if (newProgress == 100) {
814 CookieSyncManager.getInstance().sync();
815 // onProgressChanged() may continue to be called after the main
816 // frame has finished loading, as any remaining sub frames continue
817 // to load. We'll only get called once though with newProgress as
818 // 100 when everything is loaded. (onPageFinished is called once
819 // when the main frame completes loading regardless of the state of
820 // any sub frames so calls to onProgressChanges may continue after
821 // onPageFinished has executed)
822 if (mInLoad) {
823 mInLoad = false;
824 updateInLoadMenuItems(mCachedMenu);
825 }
826 } else {
827 if (!mInLoad) {
828 // onPageFinished may have already been called but a subframe is
829 // still loading and updating the progress. Reset mInLoad and
830 // update the menu items.
831 mInLoad = true;
832 updateInLoadMenuItems(mCachedMenu);
833 }
834 }
835 mUi.onProgressChanged(tab, newProgress);
836 }
837
838 @Override
839 public void onReceivedTitle(Tab tab, final String title) {
840 final String pageUrl = tab.getWebView().getUrl();
841 setUrlTitle(tab, pageUrl, title);
842 if (pageUrl == null || pageUrl.length()
843 >= SQLiteDatabase.SQLITE_MAX_LIKE_PATTERN_LENGTH) {
844 return;
845 }
846 // Update the title in the history database if not in private browsing mode
847 if (!tab.isPrivateBrowsingEnabled()) {
John Reck0ebd3ac2010-12-09 11:14:04 -0800848 mDataController.updateHistoryTitle(pageUrl, title);
Michael Kolb8233fac2010-10-26 16:08:53 -0700849 }
850 }
851
852 @Override
853 public void onFavicon(Tab tab, WebView view, Bitmap icon) {
854 mUi.setFavicon(tab, icon);
855 maybeUpdateFavicon(tab, view.getOriginalUrl(), view.getUrl(), icon);
856 }
857
858 @Override
859 public boolean shouldOverrideUrlLoading(WebView view, String url) {
860 return mUrlHandler.shouldOverrideUrlLoading(view, url);
861 }
862
863 @Override
864 public boolean shouldOverrideKeyEvent(KeyEvent event) {
865 if (mMenuIsDown) {
866 // only check shortcut key when MENU is held
867 return mActivity.getWindow().isShortcutKey(event.getKeyCode(),
868 event);
869 } else {
870 return false;
871 }
872 }
873
874 @Override
875 public void onUnhandledKeyEvent(KeyEvent event) {
876 if (!isActivityPaused()) {
877 if (event.getAction() == KeyEvent.ACTION_DOWN) {
878 mActivity.onKeyDown(event.getKeyCode(), event);
879 } else {
880 mActivity.onKeyUp(event.getKeyCode(), event);
881 }
882 }
883 }
884
885 @Override
886 public void doUpdateVisitedHistory(Tab tab, String url,
887 boolean isReload) {
888 // Don't save anything in private browsing mode
889 if (tab.isPrivateBrowsingEnabled()) return;
890
891 if (url.regionMatches(true, 0, "about:", 0, 6)) {
892 return;
893 }
John Reck0ebd3ac2010-12-09 11:14:04 -0800894 mDataController.updateVisitedHistory(url);
Michael Kolb8233fac2010-10-26 16:08:53 -0700895 WebIconDatabase.getInstance().retainIconForPageUrl(url);
896 }
897
898 @Override
899 public void getVisitedHistory(final ValueCallback<String[]> callback) {
900 AsyncTask<Void, Void, String[]> task =
901 new AsyncTask<Void, Void, String[]>() {
902 @Override
903 public String[] doInBackground(Void... unused) {
904 return Browser.getVisitedHistory(mActivity.getContentResolver());
905 }
906 @Override
907 public void onPostExecute(String[] result) {
908 callback.onReceiveValue(result);
909 }
910 };
911 task.execute();
912 }
913
914 @Override
915 public void onReceivedHttpAuthRequest(Tab tab, WebView view,
916 final HttpAuthHandler handler, final String host,
917 final String realm) {
918 String username = null;
919 String password = null;
920
921 boolean reuseHttpAuthUsernamePassword
922 = handler.useHttpAuthUsernamePassword();
923
924 if (reuseHttpAuthUsernamePassword && view != null) {
925 String[] credentials = view.getHttpAuthUsernamePassword(host, realm);
926 if (credentials != null && credentials.length == 2) {
927 username = credentials[0];
928 password = credentials[1];
929 }
930 }
931
932 if (username != null && password != null) {
933 handler.proceed(username, password);
934 } else {
935 if (tab.inForeground()) {
936 mPageDialogsHandler.showHttpAuthentication(tab, handler, host, realm);
937 } else {
938 handler.cancel();
939 }
940 }
941 }
942
943 @Override
944 public void onDownloadStart(Tab tab, String url, String userAgent,
945 String contentDisposition, String mimetype, long contentLength) {
Leon Scroggins63c02662010-11-18 15:16:27 -0500946 DownloadHandler.onDownloadStart(mActivity, url, userAgent,
947 contentDisposition, mimetype);
Michael Kolb8233fac2010-10-26 16:08:53 -0700948 if (tab.getWebView().copyBackForwardList().getSize() == 0) {
949 // This Tab was opened for the sole purpose of downloading a
950 // file. Remove it.
951 if (tab == mTabControl.getCurrentTab()) {
952 // In this case, the Tab is still on top.
953 goBackOnePageOrQuit();
954 } else {
955 // In this case, it is not.
956 closeTab(tab);
957 }
958 }
959 }
960
961 @Override
962 public Bitmap getDefaultVideoPoster() {
963 return mUi.getDefaultVideoPoster();
964 }
965
966 @Override
967 public View getVideoLoadingProgressView() {
968 return mUi.getVideoLoadingProgressView();
969 }
970
971 @Override
972 public void showSslCertificateOnError(WebView view, SslErrorHandler handler,
973 SslError error) {
974 mPageDialogsHandler.showSSLCertificateOnError(view, handler, error);
975 }
976
977 // helper method
978
979 /*
980 * Update the favorites icon if the private browsing isn't enabled and the
981 * icon is valid.
982 */
983 private void maybeUpdateFavicon(Tab tab, final String originalUrl,
984 final String url, Bitmap favicon) {
985 if (favicon == null) {
986 return;
987 }
988 if (!tab.isPrivateBrowsingEnabled()) {
989 Bookmarks.updateFavicon(mActivity
990 .getContentResolver(), originalUrl, url, favicon);
991 }
992 }
993
Leon Scroggins4cd97792010-12-03 15:31:56 -0500994 @Override
995 public void bookmarkedStatusHasChanged(Tab tab) {
996 mUi.bookmarkedStatusHasChanged(tab);
997 }
998
Michael Kolb8233fac2010-10-26 16:08:53 -0700999 // end WebViewController
1000
1001 protected void pageUp() {
1002 getCurrentTopWebView().pageUp(false);
1003 }
1004
1005 protected void pageDown() {
1006 getCurrentTopWebView().pageDown(false);
1007 }
1008
1009 // callback from phone title bar
1010 public void editUrl() {
1011 if (mOptionsMenuOpen) mActivity.closeOptionsMenu();
1012 String url = (getCurrentTopWebView() == null) ? null : getCurrentTopWebView().getUrl();
1013 startSearch(mSettings.getHomePage().equals(url) ? null : url, true,
1014 null, false);
1015 }
1016
1017 public void activateVoiceSearchMode(String title) {
1018 mUi.showVoiceTitleBar(title);
1019 }
1020
1021 public void revertVoiceSearchMode(Tab tab) {
1022 mUi.revertVoiceTitleBar(tab);
1023 }
1024
1025 public void showCustomView(Tab tab, View view,
1026 WebChromeClient.CustomViewCallback callback) {
1027 if (tab.inForeground()) {
1028 if (mUi.isCustomViewShowing()) {
1029 callback.onCustomViewHidden();
1030 return;
1031 }
1032 mUi.showCustomView(view, callback);
1033 // Save the menu state and set it to empty while the custom
1034 // view is showing.
1035 mOldMenuState = mMenuState;
1036 mMenuState = EMPTY_MENU;
1037 }
1038 }
1039
1040 @Override
1041 public void hideCustomView() {
1042 if (mUi.isCustomViewShowing()) {
1043 mUi.onHideCustomView();
1044 // Reset the old menu state.
1045 mMenuState = mOldMenuState;
1046 mOldMenuState = EMPTY_MENU;
1047 }
1048 }
1049
1050 protected void onActivityResult(int requestCode, int resultCode,
1051 Intent intent) {
1052 if (getCurrentTopWebView() == null) return;
1053 switch (requestCode) {
1054 case PREFERENCES_PAGE:
1055 if (resultCode == Activity.RESULT_OK && intent != null) {
1056 String action = intent.getStringExtra(Intent.EXTRA_TEXT);
1057 if (BrowserSettings.PREF_CLEAR_HISTORY.equals(action)) {
1058 mTabControl.removeParentChildRelationShips();
1059 }
1060 }
1061 break;
1062 case FILE_SELECTED:
1063 // Choose a file from the file picker.
1064 if (null == mUploadHandler) break;
1065 mUploadHandler.onResult(resultCode, intent);
1066 mUploadHandler = null;
1067 break;
Ben Murdoch8029a772010-11-16 11:58:21 +00001068 case AUTOFILL_SETUP:
1069 // Determine whether a profile was actually set up or not
1070 // and if so, send the message back to the WebTextView to
1071 // fill the form with the new profile.
1072 if (getSettings().getAutoFillProfile() != null) {
1073 mAutoFillSetupMessage.sendToTarget();
1074 mAutoFillSetupMessage = null;
1075 }
1076 break;
Michael Kolb8233fac2010-10-26 16:08:53 -07001077 default:
1078 break;
1079 }
1080 getCurrentTopWebView().requestFocus();
1081 }
1082
1083 /**
1084 * Open the Go page.
1085 * @param startWithHistory If true, open starting on the history tab.
1086 * Otherwise, start with the bookmarks tab.
1087 */
1088 @Override
1089 public void bookmarksOrHistoryPicker(boolean startWithHistory) {
1090 if (mTabControl.getCurrentWebView() == null) {
1091 return;
1092 }
1093 Bundle extras = new Bundle();
1094 // Disable opening in a new window if we have maxed out the windows
1095 extras.putBoolean(BrowserBookmarksPage.EXTRA_DISABLE_WINDOW,
1096 !mTabControl.canCreateNewTab());
1097 mUi.showComboView(startWithHistory, extras);
1098 }
1099
1100 // combo view callbacks
1101
1102 /**
1103 * callback from ComboPage when clear history is requested
1104 */
1105 public void onRemoveParentChildRelationships() {
1106 mTabControl.removeParentChildRelationShips();
1107 }
1108
1109 /**
1110 * callback from ComboPage when bookmark/history selection
1111 */
1112 @Override
1113 public void onUrlSelected(String url, boolean newTab) {
1114 removeComboView();
1115 if (!TextUtils.isEmpty(url)) {
1116 if (newTab) {
1117 openTab(url, false);
1118 } else {
1119 final Tab currentTab = mTabControl.getCurrentTab();
1120 dismissSubWindow(currentTab);
1121 loadUrl(getCurrentTopWebView(), url);
1122 }
1123 }
1124 }
1125
1126 /**
1127 * callback from ComboPage when dismissed
1128 */
1129 @Override
1130 public void onComboCanceled() {
1131 removeComboView();
1132 }
1133
1134 /**
1135 * dismiss the ComboPage
1136 */
1137 @Override
1138 public void removeComboView() {
1139 mUi.hideComboView();
1140 }
1141
1142 // active tabs page handling
1143
1144 protected void showActiveTabsPage() {
1145 mMenuState = EMPTY_MENU;
1146 mUi.showActiveTabsPage();
1147 }
1148
1149 /**
1150 * Remove the active tabs page.
1151 * @param needToAttach If true, the active tabs page did not attach a tab
1152 * to the content view, so we need to do that here.
1153 */
1154 @Override
1155 public void removeActiveTabsPage(boolean needToAttach) {
1156 mMenuState = R.id.MAIN_MENU;
1157 mUi.removeActiveTabsPage();
1158 if (needToAttach) {
1159 setActiveTab(mTabControl.getCurrentTab());
1160 }
1161 getCurrentTopWebView().requestFocus();
1162 }
1163
1164 // key handling
1165 protected void onBackKey() {
1166 if (!mUi.onBackKey()) {
1167 WebView subwindow = mTabControl.getCurrentSubWindow();
1168 if (subwindow != null) {
1169 if (subwindow.canGoBack()) {
1170 subwindow.goBack();
1171 } else {
1172 dismissSubWindow(mTabControl.getCurrentTab());
1173 }
1174 } else {
1175 goBackOnePageOrQuit();
1176 }
1177 }
1178 }
1179
1180 // menu handling and state
1181 // TODO: maybe put into separate handler
1182
1183 protected boolean onCreateOptionsMenu(Menu menu) {
1184 MenuInflater inflater = mActivity.getMenuInflater();
1185 inflater.inflate(R.menu.browser, menu);
1186 updateInLoadMenuItems(menu);
1187 // hold on to the menu reference here; it is used by the page callbacks
1188 // to update the menu based on loading state
1189 mCachedMenu = menu;
1190 return true;
1191 }
1192
1193 protected void onCreateContextMenu(ContextMenu menu, View v,
1194 ContextMenuInfo menuInfo) {
1195 if (v instanceof TitleBarBase) {
1196 return;
1197 }
1198 if (!(v instanceof WebView)) {
1199 return;
1200 }
Leon Scroggins026f2542010-11-22 13:26:12 -05001201 final WebView webview = (WebView) v;
Michael Kolb8233fac2010-10-26 16:08:53 -07001202 WebView.HitTestResult result = webview.getHitTestResult();
1203 if (result == null) {
1204 return;
1205 }
1206
1207 int type = result.getType();
1208 if (type == WebView.HitTestResult.UNKNOWN_TYPE) {
1209 Log.w(LOGTAG,
1210 "We should not show context menu when nothing is touched");
1211 return;
1212 }
1213 if (type == WebView.HitTestResult.EDIT_TEXT_TYPE) {
1214 // let TextView handles context menu
1215 return;
1216 }
1217
1218 // Note, http://b/issue?id=1106666 is requesting that
1219 // an inflated menu can be used again. This is not available
1220 // yet, so inflate each time (yuk!)
1221 MenuInflater inflater = mActivity.getMenuInflater();
1222 inflater.inflate(R.menu.browsercontext, menu);
1223
1224 // Show the correct menu group
1225 final String extra = result.getExtra();
1226 menu.setGroupVisible(R.id.PHONE_MENU,
1227 type == WebView.HitTestResult.PHONE_TYPE);
1228 menu.setGroupVisible(R.id.EMAIL_MENU,
1229 type == WebView.HitTestResult.EMAIL_TYPE);
1230 menu.setGroupVisible(R.id.GEO_MENU,
1231 type == WebView.HitTestResult.GEO_TYPE);
1232 menu.setGroupVisible(R.id.IMAGE_MENU,
1233 type == WebView.HitTestResult.IMAGE_TYPE
1234 || type == WebView.HitTestResult.SRC_IMAGE_ANCHOR_TYPE);
1235 menu.setGroupVisible(R.id.ANCHOR_MENU,
1236 type == WebView.HitTestResult.SRC_ANCHOR_TYPE
1237 || type == WebView.HitTestResult.SRC_IMAGE_ANCHOR_TYPE);
Cary Clark8974d282010-11-22 10:46:05 -05001238 boolean hitText = type == WebView.HitTestResult.SRC_ANCHOR_TYPE
1239 || type == WebView.HitTestResult.PHONE_TYPE
1240 || type == WebView.HitTestResult.EMAIL_TYPE
1241 || type == WebView.HitTestResult.GEO_TYPE;
1242 menu.setGroupVisible(R.id.SELECT_TEXT_MENU, hitText);
1243 if (hitText) {
1244 menu.findItem(R.id.select_text_menu_id)
1245 .setOnMenuItemClickListener(new SelectText(webview));
1246 }
Michael Kolb8233fac2010-10-26 16:08:53 -07001247 // Setup custom handling depending on the type
1248 switch (type) {
1249 case WebView.HitTestResult.PHONE_TYPE:
1250 menu.setHeaderTitle(Uri.decode(extra));
1251 menu.findItem(R.id.dial_context_menu_id).setIntent(
1252 new Intent(Intent.ACTION_VIEW, Uri
1253 .parse(WebView.SCHEME_TEL + extra)));
1254 Intent addIntent = new Intent(Intent.ACTION_INSERT_OR_EDIT);
1255 addIntent.putExtra(Insert.PHONE, Uri.decode(extra));
1256 addIntent.setType(ContactsContract.Contacts.CONTENT_ITEM_TYPE);
1257 menu.findItem(R.id.add_contact_context_menu_id).setIntent(
1258 addIntent);
1259 menu.findItem(R.id.copy_phone_context_menu_id)
1260 .setOnMenuItemClickListener(
1261 new Copy(extra));
1262 break;
1263
1264 case WebView.HitTestResult.EMAIL_TYPE:
1265 menu.setHeaderTitle(extra);
1266 menu.findItem(R.id.email_context_menu_id).setIntent(
1267 new Intent(Intent.ACTION_VIEW, Uri
1268 .parse(WebView.SCHEME_MAILTO + extra)));
1269 menu.findItem(R.id.copy_mail_context_menu_id)
1270 .setOnMenuItemClickListener(
1271 new Copy(extra));
1272 break;
1273
1274 case WebView.HitTestResult.GEO_TYPE:
1275 menu.setHeaderTitle(extra);
1276 menu.findItem(R.id.map_context_menu_id).setIntent(
1277 new Intent(Intent.ACTION_VIEW, Uri
1278 .parse(WebView.SCHEME_GEO
1279 + URLEncoder.encode(extra))));
1280 menu.findItem(R.id.copy_geo_context_menu_id)
1281 .setOnMenuItemClickListener(
1282 new Copy(extra));
1283 break;
1284
1285 case WebView.HitTestResult.SRC_ANCHOR_TYPE:
1286 case WebView.HitTestResult.SRC_IMAGE_ANCHOR_TYPE:
1287 TextView titleView = (TextView) LayoutInflater.from(mActivity)
1288 .inflate(android.R.layout.browser_link_context_header,
1289 null);
1290 titleView.setText(extra);
1291 menu.setHeaderView(titleView);
1292 // decide whether to show the open link in new tab option
1293 boolean showNewTab = mTabControl.canCreateNewTab();
1294 MenuItem newTabItem
1295 = menu.findItem(R.id.open_newtab_context_menu_id);
1296 newTabItem.setVisible(showNewTab);
1297 if (showNewTab) {
Leon Scroggins026f2542010-11-22 13:26:12 -05001298 if (WebView.HitTestResult.SRC_IMAGE_ANCHOR_TYPE == type) {
1299 newTabItem.setOnMenuItemClickListener(
1300 new MenuItem.OnMenuItemClickListener() {
1301 @Override
1302 public boolean onMenuItemClick(MenuItem item) {
1303 final HashMap<String, WebView> hrefMap =
1304 new HashMap<String, WebView>();
1305 hrefMap.put("webview", webview);
1306 final Message msg = mHandler.obtainMessage(
1307 FOCUS_NODE_HREF,
1308 R.id.open_newtab_context_menu_id,
1309 0, hrefMap);
1310 webview.requestFocusNodeHref(msg);
1311 return true;
Michael Kolb8233fac2010-10-26 16:08:53 -07001312 }
Leon Scroggins026f2542010-11-22 13:26:12 -05001313 });
1314 } else {
1315 newTabItem.setOnMenuItemClickListener(
1316 new MenuItem.OnMenuItemClickListener() {
1317 @Override
1318 public boolean onMenuItemClick(MenuItem item) {
1319 final Tab parent = mTabControl.getCurrentTab();
1320 final Tab newTab = openTab(extra, false);
1321 if (newTab != parent) {
1322 parent.addChildTab(newTab);
1323 }
1324 return true;
1325 }
1326 });
1327 }
Michael Kolb8233fac2010-10-26 16:08:53 -07001328 }
1329 menu.findItem(R.id.bookmark_context_menu_id).setVisible(
1330 Bookmarks.urlHasAcceptableScheme(extra));
1331 PackageManager pm = mActivity.getPackageManager();
1332 Intent send = new Intent(Intent.ACTION_SEND);
1333 send.setType("text/plain");
1334 ResolveInfo ri = pm.resolveActivity(send,
1335 PackageManager.MATCH_DEFAULT_ONLY);
1336 menu.findItem(R.id.share_link_context_menu_id)
1337 .setVisible(ri != null);
1338 if (type == WebView.HitTestResult.SRC_ANCHOR_TYPE) {
1339 break;
1340 }
1341 // otherwise fall through to handle image part
1342 case WebView.HitTestResult.IMAGE_TYPE:
1343 if (type == WebView.HitTestResult.IMAGE_TYPE) {
1344 menu.setHeaderTitle(extra);
1345 }
1346 menu.findItem(R.id.view_image_context_menu_id).setIntent(
1347 new Intent(Intent.ACTION_VIEW, Uri.parse(extra)));
1348 menu.findItem(R.id.download_context_menu_id).
Leon Scroggins63c02662010-11-18 15:16:27 -05001349 setOnMenuItemClickListener(new Download(mActivity, extra));
Michael Kolb8233fac2010-10-26 16:08:53 -07001350 menu.findItem(R.id.set_wallpaper_context_menu_id).
1351 setOnMenuItemClickListener(new WallpaperHandler(mActivity,
1352 extra));
1353 break;
1354
1355 default:
1356 Log.w(LOGTAG, "We should not get here.");
1357 break;
1358 }
1359 //update the ui
1360 mUi.onContextMenuCreated(menu);
1361 }
1362
1363 /**
1364 * As the menu can be open when loading state changes
1365 * we must manually update the state of the stop/reload menu
1366 * item
1367 */
1368 private void updateInLoadMenuItems(Menu menu) {
1369 if (menu == null) {
1370 return;
1371 }
1372 MenuItem dest = menu.findItem(R.id.stop_reload_menu_id);
1373 MenuItem src = mInLoad ?
1374 menu.findItem(R.id.stop_menu_id):
1375 menu.findItem(R.id.reload_menu_id);
1376 if (src != null) {
1377 dest.setIcon(src.getIcon());
1378 dest.setTitle(src.getTitle());
1379 }
1380 }
1381
1382 boolean prepareOptionsMenu(Menu menu) {
1383 // This happens when the user begins to hold down the menu key, so
1384 // allow them to chord to get a shortcut.
1385 mCanChord = true;
1386 // Note: setVisible will decide whether an item is visible; while
1387 // setEnabled() will decide whether an item is enabled, which also means
1388 // whether the matching shortcut key will function.
1389 switch (mMenuState) {
1390 case EMPTY_MENU:
1391 if (mCurrentMenuState != mMenuState) {
1392 menu.setGroupVisible(R.id.MAIN_MENU, false);
1393 menu.setGroupEnabled(R.id.MAIN_MENU, false);
1394 menu.setGroupEnabled(R.id.MAIN_SHORTCUT_MENU, false);
1395 }
1396 break;
1397 default:
1398 if (mCurrentMenuState != mMenuState) {
1399 menu.setGroupVisible(R.id.MAIN_MENU, true);
1400 menu.setGroupEnabled(R.id.MAIN_MENU, true);
1401 menu.setGroupEnabled(R.id.MAIN_SHORTCUT_MENU, true);
1402 }
1403 final WebView w = getCurrentTopWebView();
1404 boolean canGoBack = false;
1405 boolean canGoForward = false;
1406 boolean isHome = false;
1407 if (w != null) {
1408 canGoBack = w.canGoBack();
1409 canGoForward = w.canGoForward();
1410 isHome = mSettings.getHomePage().equals(w.getUrl());
1411 }
1412 final MenuItem back = menu.findItem(R.id.back_menu_id);
1413 back.setEnabled(canGoBack);
1414
1415 final MenuItem home = menu.findItem(R.id.homepage_menu_id);
1416 home.setEnabled(!isHome);
1417
1418 final MenuItem forward = menu.findItem(R.id.forward_menu_id);
1419 forward.setEnabled(canGoForward);
1420
1421 // decide whether to show the share link option
1422 PackageManager pm = mActivity.getPackageManager();
1423 Intent send = new Intent(Intent.ACTION_SEND);
1424 send.setType("text/plain");
1425 ResolveInfo ri = pm.resolveActivity(send,
1426 PackageManager.MATCH_DEFAULT_ONLY);
1427 menu.findItem(R.id.share_page_menu_id).setVisible(ri != null);
1428
1429 boolean isNavDump = mSettings.isNavDump();
1430 final MenuItem nav = menu.findItem(R.id.dump_nav_menu_id);
1431 nav.setVisible(isNavDump);
1432 nav.setEnabled(isNavDump);
1433
1434 boolean showDebugSettings = mSettings.showDebugSettings();
1435 final MenuItem counter = menu.findItem(R.id.dump_counters_menu_id);
1436 counter.setVisible(showDebugSettings);
1437 counter.setEnabled(showDebugSettings);
1438
1439 // allow the ui to adjust state based settings
1440 mUi.onPrepareOptionsMenu(menu);
1441
1442 break;
1443 }
1444 mCurrentMenuState = mMenuState;
1445 return true;
1446 }
1447
1448 public boolean onOptionsItemSelected(MenuItem item) {
1449 if (item.getGroupId() != R.id.CONTEXT_MENU) {
1450 // menu remains active, so ensure comboview is dismissed
1451 // if main menu option is selected
1452 removeComboView();
1453 }
1454 // check the action bar button before mCanChord check, as the prepare call
1455 // doesn't come for action bar buttons
1456 if (item.getItemId() == R.id.newtab) {
1457 openTabToHomePage();
1458 return true;
1459 }
1460 if (!mCanChord) {
1461 // The user has already fired a shortcut with this hold down of the
1462 // menu key.
1463 return false;
1464 }
1465 if (null == getCurrentTopWebView()) {
1466 return false;
1467 }
1468 if (mMenuIsDown) {
1469 // The shortcut action consumes the MENU. Even if it is still down,
1470 // it won't trigger the next shortcut action. In the case of the
1471 // shortcut action triggering a new activity, like Bookmarks, we
1472 // won't get onKeyUp for MENU. So it is important to reset it here.
1473 mMenuIsDown = false;
1474 }
1475 switch (item.getItemId()) {
1476 // -- Main menu
1477 case R.id.new_tab_menu_id:
1478 openTabToHomePage();
1479 break;
1480
1481 case R.id.incognito_menu_id:
1482 openIncognitoTab();
1483 break;
1484
1485 case R.id.goto_menu_id:
1486 editUrl();
1487 break;
1488
1489 case R.id.bookmarks_menu_id:
1490 bookmarksOrHistoryPicker(false);
1491 break;
1492
1493 case R.id.active_tabs_menu_id:
1494 showActiveTabsPage();
1495 break;
1496
1497 case R.id.add_bookmark_menu_id:
1498 bookmarkCurrentPage(AddBookmarkPage.DEFAULT_FOLDER_ID);
1499 break;
1500
1501 case R.id.stop_reload_menu_id:
1502 if (mInLoad) {
1503 stopLoading();
1504 } else {
1505 getCurrentTopWebView().reload();
1506 }
1507 break;
1508
1509 case R.id.back_menu_id:
1510 getCurrentTopWebView().goBack();
1511 break;
1512
1513 case R.id.forward_menu_id:
1514 getCurrentTopWebView().goForward();
1515 break;
1516
1517 case R.id.close_menu_id:
1518 // Close the subwindow if it exists.
1519 if (mTabControl.getCurrentSubWindow() != null) {
1520 dismissSubWindow(mTabControl.getCurrentTab());
1521 break;
1522 }
1523 closeCurrentTab();
1524 break;
1525
1526 case R.id.homepage_menu_id:
1527 Tab current = mTabControl.getCurrentTab();
1528 if (current != null) {
1529 dismissSubWindow(current);
1530 loadUrl(current.getWebView(), mSettings.getHomePage());
1531 }
1532 break;
1533
1534 case R.id.preferences_menu_id:
1535 Intent intent = new Intent(mActivity, BrowserPreferencesPage.class);
1536 intent.putExtra(BrowserPreferencesPage.CURRENT_PAGE,
1537 getCurrentTopWebView().getUrl());
1538 mActivity.startActivityForResult(intent, PREFERENCES_PAGE);
1539 break;
1540
1541 case R.id.find_menu_id:
1542 getCurrentTopWebView().showFindDialog(null);
1543 break;
1544
1545 case R.id.page_info_menu_id:
1546 mPageDialogsHandler.showPageInfo(mTabControl.getCurrentTab(),
1547 false);
1548 break;
1549
1550 case R.id.classic_history_menu_id:
1551 bookmarksOrHistoryPicker(true);
1552 break;
1553
1554 case R.id.title_bar_share_page_url:
1555 case R.id.share_page_menu_id:
1556 Tab currentTab = mTabControl.getCurrentTab();
1557 if (null == currentTab) {
1558 mCanChord = false;
1559 return false;
1560 }
Michael Kolbba99c5d2010-11-29 14:57:41 -08001561 shareCurrentPage(currentTab);
Michael Kolb8233fac2010-10-26 16:08:53 -07001562 break;
1563
1564 case R.id.dump_nav_menu_id:
1565 getCurrentTopWebView().debugDump();
1566 break;
1567
1568 case R.id.dump_counters_menu_id:
1569 getCurrentTopWebView().dumpV8Counters();
1570 break;
1571
1572 case R.id.zoom_in_menu_id:
1573 getCurrentTopWebView().zoomIn();
1574 break;
1575
1576 case R.id.zoom_out_menu_id:
1577 getCurrentTopWebView().zoomOut();
1578 break;
1579
1580 case R.id.view_downloads_menu_id:
1581 viewDownloads();
1582 break;
1583
1584 case R.id.window_one_menu_id:
1585 case R.id.window_two_menu_id:
1586 case R.id.window_three_menu_id:
1587 case R.id.window_four_menu_id:
1588 case R.id.window_five_menu_id:
1589 case R.id.window_six_menu_id:
1590 case R.id.window_seven_menu_id:
1591 case R.id.window_eight_menu_id:
1592 {
1593 int menuid = item.getItemId();
1594 for (int id = 0; id < WINDOW_SHORTCUT_ID_ARRAY.length; id++) {
1595 if (WINDOW_SHORTCUT_ID_ARRAY[id] == menuid) {
1596 Tab desiredTab = mTabControl.getTab(id);
1597 if (desiredTab != null &&
1598 desiredTab != mTabControl.getCurrentTab()) {
1599 switchToTab(id);
1600 }
1601 break;
1602 }
1603 }
1604 }
1605 break;
1606
1607 default:
1608 return false;
1609 }
1610 mCanChord = false;
1611 return true;
1612 }
1613
1614 public boolean onContextItemSelected(MenuItem item) {
John Reckdbf57df2010-11-09 16:34:03 -08001615 // Let the History and Bookmark fragments handle menus they created.
1616 if (item.getGroupId() == R.id.CONTEXT_MENU) {
1617 return false;
1618 }
1619
Michael Kolb8233fac2010-10-26 16:08:53 -07001620 // chording is not an issue with context menus, but we use the same
1621 // options selector, so set mCanChord to true so we can access them.
1622 mCanChord = true;
1623 int id = item.getItemId();
1624 boolean result = true;
1625 switch (id) {
1626 // For the context menu from the title bar
1627 case R.id.title_bar_copy_page_url:
1628 Tab currentTab = mTabControl.getCurrentTab();
1629 if (null == currentTab) {
1630 result = false;
1631 break;
1632 }
1633 WebView mainView = currentTab.getWebView();
1634 if (null == mainView) {
1635 result = false;
1636 break;
1637 }
1638 copy(mainView.getUrl());
1639 break;
1640 // -- Browser context menu
1641 case R.id.open_context_menu_id:
1642 case R.id.bookmark_context_menu_id:
1643 case R.id.save_link_context_menu_id:
1644 case R.id.share_link_context_menu_id:
1645 case R.id.copy_link_context_menu_id:
1646 final WebView webView = getCurrentTopWebView();
1647 if (null == webView) {
1648 result = false;
1649 break;
1650 }
1651 final HashMap<String, WebView> hrefMap =
1652 new HashMap<String, WebView>();
1653 hrefMap.put("webview", webView);
1654 final Message msg = mHandler.obtainMessage(
1655 FOCUS_NODE_HREF, id, 0, hrefMap);
1656 webView.requestFocusNodeHref(msg);
1657 break;
1658
1659 default:
1660 // For other context menus
1661 result = onOptionsItemSelected(item);
1662 }
1663 mCanChord = false;
1664 return result;
1665 }
1666
1667 /**
1668 * support programmatically opening the context menu
1669 */
1670 public void openContextMenu(View view) {
1671 mActivity.openContextMenu(view);
1672 }
1673
1674 /**
1675 * programmatically open the options menu
1676 */
1677 public void openOptionsMenu() {
1678 mActivity.openOptionsMenu();
1679 }
1680
1681 public boolean onMenuOpened(int featureId, Menu menu) {
1682 if (mOptionsMenuOpen) {
1683 if (mConfigChanged) {
1684 // We do not need to make any changes to the state of the
1685 // title bar, since the only thing that happened was a
1686 // change in orientation
1687 mConfigChanged = false;
1688 } else {
1689 if (!mExtendedMenuOpen) {
1690 mExtendedMenuOpen = true;
1691 mUi.onExtendedMenuOpened();
1692 } else {
1693 // Switching the menu back to icon view, so show the
1694 // title bar once again.
1695 mExtendedMenuOpen = false;
1696 mUi.onExtendedMenuClosed(mInLoad);
1697 mUi.onOptionsMenuOpened();
1698 }
1699 }
1700 } else {
1701 // The options menu is closed, so open it, and show the title
1702 mOptionsMenuOpen = true;
1703 mConfigChanged = false;
1704 mExtendedMenuOpen = false;
1705 mUi.onOptionsMenuOpened();
1706 }
1707 return true;
1708 }
1709
1710 public void onOptionsMenuClosed(Menu menu) {
1711 mOptionsMenuOpen = false;
1712 mUi.onOptionsMenuClosed(mInLoad);
1713 }
1714
1715 public void onContextMenuClosed(Menu menu) {
1716 mUi.onContextMenuClosed(menu, mInLoad);
1717 }
1718
1719 // Helper method for getting the top window.
1720 @Override
1721 public WebView getCurrentTopWebView() {
1722 return mTabControl.getCurrentTopWebView();
1723 }
1724
1725 @Override
1726 public WebView getCurrentWebView() {
1727 return mTabControl.getCurrentWebView();
1728 }
1729
1730 /*
1731 * This method is called as a result of the user selecting the options
1732 * menu to see the download window. It shows the download window on top of
1733 * the current window.
1734 */
1735 void viewDownloads() {
1736 Intent intent = new Intent(DownloadManager.ACTION_VIEW_DOWNLOADS);
1737 mActivity.startActivity(intent);
1738 }
1739
1740 // action mode
1741
1742 void onActionModeStarted(ActionMode mode) {
1743 mUi.onActionModeStarted(mode);
1744 mActionMode = mode;
1745 }
1746
1747 /*
1748 * True if a custom ActionMode (i.e. find or select) is in use.
1749 */
1750 @Override
1751 public boolean isInCustomActionMode() {
1752 return mActionMode != null;
1753 }
1754
1755 /*
1756 * End the current ActionMode.
1757 */
1758 @Override
1759 public void endActionMode() {
1760 if (mActionMode != null) {
1761 mActionMode.finish();
1762 }
1763 }
1764
1765 /*
1766 * Called by find and select when they are finished. Replace title bars
1767 * as necessary.
1768 */
1769 public void onActionModeFinished(ActionMode mode) {
1770 if (!isInCustomActionMode()) return;
1771 mUi.onActionModeFinished(mInLoad);
1772 mActionMode = null;
1773 }
1774
1775 boolean isInLoad() {
1776 return mInLoad;
1777 }
1778
1779 // bookmark handling
1780
1781 /**
1782 * add the current page as a bookmark to the given folder id
1783 * @param folderId use -1 for the default folder
1784 */
1785 @Override
1786 public void bookmarkCurrentPage(long folderId) {
1787 Intent i = new Intent(mActivity,
1788 AddBookmarkPage.class);
1789 WebView w = getCurrentTopWebView();
1790 i.putExtra(BrowserContract.Bookmarks.URL, w.getUrl());
1791 i.putExtra(BrowserContract.Bookmarks.TITLE, w.getTitle());
1792 String touchIconUrl = w.getTouchIconUrl();
1793 if (touchIconUrl != null) {
1794 i.putExtra(AddBookmarkPage.TOUCH_ICON_URL, touchIconUrl);
1795 WebSettings settings = w.getSettings();
1796 if (settings != null) {
1797 i.putExtra(AddBookmarkPage.USER_AGENT,
1798 settings.getUserAgentString());
1799 }
1800 }
1801 i.putExtra(BrowserContract.Bookmarks.THUMBNAIL,
1802 createScreenshot(w, getDesiredThumbnailWidth(mActivity),
1803 getDesiredThumbnailHeight(mActivity)));
1804 i.putExtra(BrowserContract.Bookmarks.FAVICON, w.getFavicon());
1805 i.putExtra(BrowserContract.Bookmarks.PARENT,
1806 folderId);
1807 // Put the dialog at the upper right of the screen, covering the
1808 // star on the title bar.
1809 i.putExtra("gravity", Gravity.RIGHT | Gravity.TOP);
1810 mActivity.startActivity(i);
1811 }
1812
1813 // file chooser
1814 public void openFileChooser(ValueCallback<Uri> uploadMsg, String acceptType) {
1815 mUploadHandler = new UploadHandler(this);
1816 mUploadHandler.openFileChooser(uploadMsg, acceptType);
1817 }
1818
1819 // thumbnails
1820
1821 /**
1822 * Return the desired width for thumbnail screenshots, which are stored in
1823 * the database, and used on the bookmarks screen.
1824 * @param context Context for finding out the density of the screen.
1825 * @return desired width for thumbnail screenshot.
1826 */
1827 static int getDesiredThumbnailWidth(Context context) {
1828 return context.getResources().getDimensionPixelOffset(
1829 R.dimen.bookmarkThumbnailWidth);
1830 }
1831
1832 /**
1833 * Return the desired height for thumbnail screenshots, which are stored in
1834 * the database, and used on the bookmarks screen.
1835 * @param context Context for finding out the density of the screen.
1836 * @return desired height for thumbnail screenshot.
1837 */
1838 static int getDesiredThumbnailHeight(Context context) {
1839 return context.getResources().getDimensionPixelOffset(
1840 R.dimen.bookmarkThumbnailHeight);
1841 }
1842
1843 private static Bitmap createScreenshot(WebView view, int width, int height) {
1844 Picture thumbnail = view.capturePicture();
1845 if (thumbnail == null) {
1846 return null;
1847 }
1848 Bitmap bm = Bitmap.createBitmap(width, height, Bitmap.Config.RGB_565);
1849 Canvas canvas = new Canvas(bm);
1850 // May need to tweak these values to determine what is the
1851 // best scale factor
1852 int thumbnailWidth = thumbnail.getWidth();
1853 int thumbnailHeight = thumbnail.getHeight();
John Reckfe49ab42010-11-16 17:09:37 -08001854 float scaleFactor = 1.0f;
Michael Kolb8233fac2010-10-26 16:08:53 -07001855 if (thumbnailWidth > 0) {
John Reckfe49ab42010-11-16 17:09:37 -08001856 scaleFactor = (float) width / (float)thumbnailWidth;
Michael Kolb8233fac2010-10-26 16:08:53 -07001857 } else {
1858 return null;
1859 }
John Reckfe49ab42010-11-16 17:09:37 -08001860
Michael Kolb8233fac2010-10-26 16:08:53 -07001861 if (view.getWidth() > view.getHeight() &&
1862 thumbnailHeight < view.getHeight() && thumbnailHeight > 0) {
1863 // If the device is in landscape and the page is shorter
John Reckfe49ab42010-11-16 17:09:37 -08001864 // than the height of the view, center the thumnail and crop the sides
1865 scaleFactor = (float) height / (float)thumbnailHeight;
1866 float wx = (thumbnailWidth * scaleFactor) - width;
1867 canvas.translate((int) -(wx / 2), 0);
Michael Kolb8233fac2010-10-26 16:08:53 -07001868 }
1869
John Reckfe49ab42010-11-16 17:09:37 -08001870 canvas.scale(scaleFactor, scaleFactor);
Michael Kolb8233fac2010-10-26 16:08:53 -07001871
1872 thumbnail.draw(canvas);
1873 return bm;
1874 }
1875
1876 private void updateScreenshot(WebView view) {
1877 // If this is a bookmarked site, add a screenshot to the database.
1878 // FIXME: When should we update? Every time?
1879 // FIXME: Would like to make sure there is actually something to
1880 // draw, but the API for that (WebViewCore.pictureReady()) is not
1881 // currently accessible here.
1882
1883 final Bitmap bm = createScreenshot(view, getDesiredThumbnailWidth(mActivity),
1884 getDesiredThumbnailHeight(mActivity));
1885 if (bm == null) {
1886 return;
1887 }
1888
1889 final ContentResolver cr = mActivity.getContentResolver();
1890 final String url = view.getUrl();
1891 final String originalUrl = view.getOriginalUrl();
1892
1893 new AsyncTask<Void, Void, Void>() {
1894 @Override
1895 protected Void doInBackground(Void... unused) {
1896 Cursor cursor = null;
1897 try {
1898 cursor = Bookmarks.queryCombinedForUrl(cr, originalUrl, url);
1899 if (cursor != null && cursor.moveToFirst()) {
1900 final ByteArrayOutputStream os =
1901 new ByteArrayOutputStream();
1902 bm.compress(Bitmap.CompressFormat.PNG, 100, os);
1903
1904 ContentValues values = new ContentValues();
1905 values.put(Images.THUMBNAIL, os.toByteArray());
1906 values.put(Images.URL, cursor.getString(0));
1907
1908 do {
1909 cr.update(Images.CONTENT_URI, values, null, null);
1910 } while (cursor.moveToNext());
1911 }
1912 } catch (IllegalStateException e) {
1913 // Ignore
1914 } finally {
1915 if (cursor != null) cursor.close();
1916 }
1917 return null;
1918 }
1919 }.execute();
1920 }
1921
1922 private class Copy implements OnMenuItemClickListener {
1923 private CharSequence mText;
1924
1925 public boolean onMenuItemClick(MenuItem item) {
1926 copy(mText);
1927 return true;
1928 }
1929
1930 public Copy(CharSequence toCopy) {
1931 mText = toCopy;
1932 }
1933 }
1934
Leon Scroggins63c02662010-11-18 15:16:27 -05001935 private static class Download implements OnMenuItemClickListener {
1936 private Activity mActivity;
Michael Kolb8233fac2010-10-26 16:08:53 -07001937 private String mText;
1938
1939 public boolean onMenuItemClick(MenuItem item) {
Leon Scroggins63c02662010-11-18 15:16:27 -05001940 DownloadHandler.onDownloadStartNoStream(mActivity, mText, null,
1941 null, null);
Michael Kolb8233fac2010-10-26 16:08:53 -07001942 return true;
1943 }
1944
Leon Scroggins63c02662010-11-18 15:16:27 -05001945 public Download(Activity activity, String toDownload) {
1946 mActivity = activity;
Michael Kolb8233fac2010-10-26 16:08:53 -07001947 mText = toDownload;
1948 }
1949 }
1950
Cary Clark8974d282010-11-22 10:46:05 -05001951 private static class SelectText implements OnMenuItemClickListener {
1952 private WebView mWebView;
1953
1954 public boolean onMenuItemClick(MenuItem item) {
1955 if (mWebView != null) {
1956 return mWebView.selectText();
1957 }
1958 return false;
1959 }
1960
1961 public SelectText(WebView webView) {
1962 mWebView = webView;
1963 }
1964
1965 }
1966
Michael Kolb8233fac2010-10-26 16:08:53 -07001967 /********************** TODO: UI stuff *****************************/
1968
1969 // these methods have been copied, they still need to be cleaned up
1970
1971 /****************** tabs ***************************************************/
1972
1973 // basic tab interactions:
1974
1975 // it is assumed that tabcontrol already knows about the tab
1976 protected void addTab(Tab tab) {
1977 mUi.addTab(tab);
1978 }
1979
1980 protected void removeTab(Tab tab) {
1981 mUi.removeTab(tab);
1982 mTabControl.removeTab(tab);
1983 }
1984
1985 protected void setActiveTab(Tab tab) {
Michael Kolb8233fac2010-10-26 16:08:53 -07001986 mTabControl.setCurrentTab(tab);
Michael Kolb77df4562010-11-19 14:49:34 -08001987 // the tab is guaranteed to have a webview after setCurrentTab
1988 mUi.setActiveTab(tab);
Michael Kolb8233fac2010-10-26 16:08:53 -07001989 }
1990
1991 protected void closeEmptyChildTab() {
1992 Tab current = mTabControl.getCurrentTab();
1993 if (current != null
1994 && current.getWebView().copyBackForwardList().getSize() == 0) {
1995 Tab parent = current.getParentTab();
1996 if (parent != null) {
1997 switchToTab(mTabControl.getTabIndex(parent));
1998 closeTab(current);
1999 }
2000 }
2001 }
2002
2003 protected void reuseTab(Tab appTab, String appId, UrlData urlData) {
2004 Log.i(LOGTAG, "Reusing tab for " + appId);
2005 // Dismiss the subwindow if applicable.
2006 dismissSubWindow(appTab);
2007 // Since we might kill the WebView, remove it from the
2008 // content view first.
2009 mUi.detachTab(appTab);
2010 // Recreate the main WebView after destroying the old one.
2011 // If the WebView has the same original url and is on that
2012 // page, it can be reused.
2013 boolean needsLoad =
2014 mTabControl.recreateWebView(appTab, urlData);
2015 // TODO: analyze why the remove and add are necessary
2016 mUi.attachTab(appTab);
2017 if (mTabControl.getCurrentTab() != appTab) {
2018 switchToTab(mTabControl.getTabIndex(appTab));
2019 if (needsLoad) {
2020 loadUrlDataIn(appTab, urlData);
2021 }
2022 } else {
2023 // If the tab was the current tab, we have to attach
2024 // it to the view system again.
2025 setActiveTab(appTab);
2026 if (needsLoad) {
2027 loadUrlDataIn(appTab, urlData);
2028 }
2029 }
2030 }
2031
2032 // Remove the sub window if it exists. Also called by TabControl when the
2033 // user clicks the 'X' to dismiss a sub window.
2034 public void dismissSubWindow(Tab tab) {
2035 removeSubWindow(tab);
2036 // dismiss the subwindow. This will destroy the WebView.
2037 tab.dismissSubWindow();
2038 getCurrentTopWebView().requestFocus();
2039 }
2040
2041 @Override
2042 public void removeSubWindow(Tab t) {
2043 if (t.getSubWebView() != null) {
2044 mUi.removeSubWindow(t.getSubViewContainer());
2045 }
2046 }
2047
2048 @Override
2049 public void attachSubWindow(Tab tab) {
2050 if (tab.getSubWebView() != null) {
2051 mUi.attachSubWindow(tab.getSubViewContainer());
2052 getCurrentTopWebView().requestFocus();
2053 }
2054 }
2055
Michael Kolb843510f2010-12-09 10:51:49 -08002056 @Override
2057 public Tab openTabToHomePage() {
2058 // check for max tabs
2059 if (mTabControl.canCreateNewTab()) {
2060 return openTabAndShow(mSettings.getHomePage(), false, null);
2061 } else {
2062 mUi.showMaxTabsWarning();
2063 return null;
2064 }
2065 }
2066
Michael Kolb8233fac2010-10-26 16:08:53 -07002067 // A wrapper function of {@link #openTabAndShow(UrlData, boolean, String)}
2068 // that accepts url as string.
Michael Kolb8233fac2010-10-26 16:08:53 -07002069 protected Tab openTabAndShow(String url, boolean closeOnExit, String appId) {
2070 return openTabAndShow(new UrlData(url), closeOnExit, appId);
2071 }
2072
2073 // This method does a ton of stuff. It will attempt to create a new tab
2074 // if we haven't reached MAX_TABS. Otherwise it uses the current tab. If
2075 // url isn't null, it will load the given url.
2076
2077 public Tab openTabAndShow(UrlData urlData, boolean closeOnExit,
2078 String appId) {
2079 final Tab currentTab = mTabControl.getCurrentTab();
2080 if (mTabControl.canCreateNewTab()) {
2081 final Tab tab = mTabControl.createNewTab(closeOnExit, appId,
2082 urlData.mUrl, false);
2083 WebView webview = tab.getWebView();
2084 // We must set the new tab as the current tab to reflect the old
2085 // animation behavior.
2086 addTab(tab);
2087 setActiveTab(tab);
2088 if (!urlData.isEmpty()) {
2089 loadUrlDataIn(tab, urlData);
2090 }
2091 return tab;
2092 } else {
2093 // Get rid of the subwindow if it exists
2094 dismissSubWindow(currentTab);
2095 if (!urlData.isEmpty()) {
2096 // Load the given url.
2097 loadUrlDataIn(currentTab, urlData);
2098 }
2099 return currentTab;
2100 }
2101 }
2102
2103 protected Tab openTab(String url, boolean forceForeground) {
2104 if (mSettings.openInBackground() && !forceForeground) {
2105 Tab tab = mTabControl.createNewTab();
2106 if (tab != null) {
2107 addTab(tab);
2108 WebView view = tab.getWebView();
2109 loadUrl(view, url);
2110 }
2111 return tab;
2112 } else {
2113 return openTabAndShow(url, false, null);
2114 }
2115 }
2116
2117 @Override
2118 public Tab openIncognitoTab() {
2119 if (mTabControl.canCreateNewTab()) {
2120 Tab currentTab = mTabControl.getCurrentTab();
2121 Tab tab = mTabControl.createNewTab(false, null, null, true);
2122 addTab(tab);
2123 setActiveTab(tab);
2124 return tab;
Michael Kolb843510f2010-12-09 10:51:49 -08002125 } else {
2126 mUi.showMaxTabsWarning();
2127 return null;
Michael Kolb8233fac2010-10-26 16:08:53 -07002128 }
Michael Kolb8233fac2010-10-26 16:08:53 -07002129 }
2130
2131 /**
2132 * @param index Index of the tab to change to, as defined by
2133 * mTabControl.getTabIndex(Tab t).
2134 * @return boolean True if we successfully switched to a different tab. If
2135 * the indexth tab is null, or if that tab is the same as
2136 * the current one, return false.
2137 */
2138 @Override
2139 public boolean switchToTab(int index) {
Michael Kolb14ee8fb2010-12-09 09:08:20 -08002140 // hide combo view if open
2141 removeComboView();
Michael Kolb8233fac2010-10-26 16:08:53 -07002142 Tab tab = mTabControl.getTab(index);
2143 Tab currentTab = mTabControl.getCurrentTab();
2144 if (tab == null || tab == currentTab) {
2145 return false;
2146 }
2147 setActiveTab(tab);
2148 return true;
2149 }
2150
2151 @Override
Michael Kolb8233fac2010-10-26 16:08:53 -07002152 public void closeCurrentTab() {
Michael Kolb14ee8fb2010-12-09 09:08:20 -08002153 // hide combo view if open
2154 removeComboView();
Michael Kolb8233fac2010-10-26 16:08:53 -07002155 final Tab current = mTabControl.getCurrentTab();
2156 if (mTabControl.getTabCount() == 1) {
2157 // This is the last tab. Open a new one, with the home
2158 // page and close the current one.
2159 openTabToHomePage();
2160 closeTab(current);
2161 return;
2162 }
2163 final Tab parent = current.getParentTab();
2164 int indexToShow = -1;
2165 if (parent != null) {
2166 indexToShow = mTabControl.getTabIndex(parent);
2167 } else {
2168 final int currentIndex = mTabControl.getCurrentIndex();
2169 // Try to move to the tab to the right
2170 indexToShow = currentIndex + 1;
2171 if (indexToShow > mTabControl.getTabCount() - 1) {
2172 // Try to move to the tab to the left
2173 indexToShow = currentIndex - 1;
2174 }
2175 }
2176 if (switchToTab(indexToShow)) {
2177 // Close window
2178 closeTab(current);
2179 }
2180 }
2181
2182 /**
2183 * Close the tab, remove its associated title bar, and adjust mTabControl's
2184 * current tab to a valid value.
2185 */
2186 @Override
2187 public void closeTab(Tab tab) {
Michael Kolb14ee8fb2010-12-09 09:08:20 -08002188 // hide combo view if open
2189 removeComboView();
Michael Kolb8233fac2010-10-26 16:08:53 -07002190 int currentIndex = mTabControl.getCurrentIndex();
2191 int removeIndex = mTabControl.getTabIndex(tab);
2192 removeTab(tab);
2193 if (currentIndex >= removeIndex && currentIndex != 0) {
2194 currentIndex--;
2195 }
2196 Tab newtab = mTabControl.getTab(currentIndex);
2197 setActiveTab(newtab);
2198 if (!mTabControl.hasAnyOpenIncognitoTabs()) {
Steve Block83101a82010-11-26 11:33:35 +00002199 WebView.cleanupPrivateBrowsingFiles();
Michael Kolb8233fac2010-10-26 16:08:53 -07002200 }
2201 }
2202
2203 /**************** TODO: Url loading clean up *******************************/
2204
2205 // Called when loading from context menu or LOAD_URL message
2206 protected void loadUrlFromContext(WebView view, String url) {
2207 // In case the user enters nothing.
2208 if (url != null && url.length() != 0 && view != null) {
2209 url = UrlUtils.smartUrlFilter(url);
2210 if (!view.getWebViewClient().shouldOverrideUrlLoading(view, url)) {
2211 loadUrl(view, url);
2212 }
2213 }
2214 }
2215
2216 /**
2217 * Load the URL into the given WebView and update the title bar
2218 * to reflect the new load. Call this instead of WebView.loadUrl
2219 * directly.
2220 * @param view The WebView used to load url.
2221 * @param url The URL to load.
2222 */
2223 protected void loadUrl(WebView view, String url) {
Michael Kolb8233fac2010-10-26 16:08:53 -07002224 view.loadUrl(url);
2225 }
2226
2227 /**
2228 * Load UrlData into a Tab and update the title bar to reflect the new
2229 * load. Call this instead of UrlData.loadIn directly.
2230 * @param t The Tab used to load.
2231 * @param data The UrlData being loaded.
2232 */
2233 protected void loadUrlDataIn(Tab t, UrlData data) {
Michael Kolb8233fac2010-10-26 16:08:53 -07002234 data.loadIn(t);
2235 }
2236
2237 /**
2238 * Resets the browser title-view to whatever it must be
2239 * (for example, if we had a loading error)
2240 * When we have a new page, we call resetTitle, when we
2241 * have to reset the titlebar to whatever it used to be
2242 * (for example, if the user chose to stop loading), we
2243 * call resetTitleAndRevertLockIcon.
2244 */
2245 public void resetTitleAndRevertLockIcon(Tab tab) {
2246 mUi.resetTitleAndRevertLockIcon(tab);
2247 }
2248
2249 void resetTitleAndIcon(Tab tab) {
2250 mUi.resetTitleAndIcon(tab);
2251 }
2252
2253 /**
Michael Kolb8233fac2010-10-26 16:08:53 -07002254 * Sets a title composed of the URL and the title string.
2255 * @param url The URL of the site being loaded.
2256 * @param title The title of the site being loaded.
2257 */
2258 void setUrlTitle(Tab tab, String url, String title) {
2259 tab.setCurrentUrl(url);
2260 tab.setCurrentTitle(title);
2261 // If we are in voice search mode, the title has already been set.
2262 if (tab.isInVoiceSearchMode()) return;
2263 mUi.setUrlTitle(tab, url, title);
2264 }
2265
2266 void goBackOnePageOrQuit() {
2267 Tab current = mTabControl.getCurrentTab();
2268 if (current == null) {
2269 /*
2270 * Instead of finishing the activity, simply push this to the back
2271 * of the stack and let ActivityManager to choose the foreground
2272 * activity. As BrowserActivity is singleTask, it will be always the
2273 * root of the task. So we can use either true or false for
2274 * moveTaskToBack().
2275 */
2276 mActivity.moveTaskToBack(true);
2277 return;
2278 }
2279 WebView w = current.getWebView();
2280 if (w.canGoBack()) {
2281 w.goBack();
2282 } else {
2283 // Check to see if we are closing a window that was created by
2284 // another window. If so, we switch back to that window.
2285 Tab parent = current.getParentTab();
2286 if (parent != null) {
2287 switchToTab(mTabControl.getTabIndex(parent));
2288 // Now we close the other tab
2289 closeTab(current);
2290 } else {
2291 if (current.closeOnExit()) {
2292 // force the tab's inLoad() to be false as we are going to
2293 // either finish the activity or remove the tab. This will
2294 // ensure pauseWebViewTimers() taking action.
Michael Kolb70976932010-11-30 11:34:01 -08002295 current.clearInPageLoad();
Michael Kolb8233fac2010-10-26 16:08:53 -07002296 if (mTabControl.getTabCount() == 1) {
2297 mActivity.finish();
2298 return;
2299 }
2300 if (mActivityPaused) {
2301 Log.e(LOGTAG, "BrowserActivity is already paused "
2302 + "while handing goBackOnePageOrQuit.");
2303 }
Michael Kolb70976932010-11-30 11:34:01 -08002304 pauseWebViewTimers(current);
Michael Kolb8233fac2010-10-26 16:08:53 -07002305 removeTab(current);
2306 }
2307 /*
2308 * Instead of finishing the activity, simply push this to the back
2309 * of the stack and let ActivityManager to choose the foreground
2310 * activity. As BrowserActivity is singleTask, it will be always the
2311 * root of the task. So we can use either true or false for
2312 * moveTaskToBack().
2313 */
2314 mActivity.moveTaskToBack(true);
2315 }
2316 }
2317 }
2318
2319 /**
2320 * Feed the previously stored results strings to the BrowserProvider so that
2321 * the SearchDialog will show them instead of the standard searches.
2322 * @param result String to show on the editable line of the SearchDialog.
2323 */
2324 @Override
2325 public void showVoiceSearchResults(String result) {
2326 ContentProviderClient client = mActivity.getContentResolver()
2327 .acquireContentProviderClient(Browser.BOOKMARKS_URI);
2328 ContentProvider prov = client.getLocalContentProvider();
2329 BrowserProvider bp = (BrowserProvider) prov;
2330 bp.setQueryResults(mTabControl.getCurrentTab().getVoiceSearchResults());
2331 client.release();
2332
2333 Bundle bundle = createGoogleSearchSourceBundle(
2334 GOOGLE_SEARCH_SOURCE_SEARCHKEY);
2335 bundle.putBoolean(SearchManager.CONTEXT_IS_VOICE, true);
2336 startSearch(result, false, bundle, false);
2337 }
2338
2339 private void startSearch(String initialQuery, boolean selectInitialQuery,
2340 Bundle appSearchData, boolean globalSearch) {
2341 if (appSearchData == null) {
2342 appSearchData = createGoogleSearchSourceBundle(
2343 GOOGLE_SEARCH_SOURCE_TYPE);
2344 }
2345
2346 SearchEngine searchEngine = mSettings.getSearchEngine();
2347 if (searchEngine != null && !searchEngine.supportsVoiceSearch()) {
2348 appSearchData.putBoolean(SearchManager.DISABLE_VOICE_SEARCH, true);
2349 }
2350 mActivity.startSearch(initialQuery, selectInitialQuery, appSearchData,
2351 globalSearch);
2352 }
2353
2354 private Bundle createGoogleSearchSourceBundle(String source) {
2355 Bundle bundle = new Bundle();
2356 bundle.putString(Search.SOURCE, source);
2357 return bundle;
2358 }
2359
2360 /**
2361 * handle key events in browser
2362 *
2363 * @param keyCode
2364 * @param event
2365 * @return true if handled, false to pass to super
2366 */
2367 boolean onKeyDown(int keyCode, KeyEvent event) {
2368 // Even if MENU is already held down, we need to call to super to open
2369 // the IME on long press.
2370 if (KeyEvent.KEYCODE_MENU == keyCode) {
2371 mMenuIsDown = true;
2372 return false;
2373 }
2374 // The default key mode is DEFAULT_KEYS_SEARCH_LOCAL. As the MENU is
2375 // still down, we don't want to trigger the search. Pretend to consume
2376 // the key and do nothing.
2377 if (mMenuIsDown) return true;
2378
2379 switch(keyCode) {
2380 case KeyEvent.KEYCODE_SPACE:
2381 // WebView/WebTextView handle the keys in the KeyDown. As
2382 // the Activity's shortcut keys are only handled when WebView
2383 // doesn't, have to do it in onKeyDown instead of onKeyUp.
2384 if (event.isShiftPressed()) {
2385 pageUp();
2386 } else {
2387 pageDown();
2388 }
2389 return true;
2390 case KeyEvent.KEYCODE_BACK:
2391 if (event.getRepeatCount() == 0) {
2392 event.startTracking();
2393 return true;
2394 } else if (mUi.showsWeb()
2395 && event.isLongPress()) {
2396 bookmarksOrHistoryPicker(true);
2397 return true;
2398 }
2399 break;
2400 }
2401 return false;
2402 }
2403
2404 boolean onKeyUp(int keyCode, KeyEvent event) {
2405 switch(keyCode) {
2406 case KeyEvent.KEYCODE_MENU:
2407 mMenuIsDown = false;
2408 break;
2409 case KeyEvent.KEYCODE_BACK:
2410 if (event.isTracking() && !event.isCanceled()) {
2411 onBackKey();
2412 return true;
2413 }
2414 break;
2415 }
2416 return false;
2417 }
2418
2419 public boolean isMenuDown() {
2420 return mMenuIsDown;
2421 }
2422
Ben Murdoch8029a772010-11-16 11:58:21 +00002423 public void setupAutoFill(Message message) {
2424 // Open the settings activity at the AutoFill profile fragment so that
2425 // the user can create a new profile. When they return, we will dispatch
2426 // the message so that we can autofill the form using their new profile.
2427 Intent intent = new Intent(mActivity, BrowserPreferencesPage.class);
2428 intent.putExtra(PreferenceActivity.EXTRA_SHOW_FRAGMENT,
2429 AutoFillSettingsFragment.class.getName());
2430 mAutoFillSetupMessage = message;
2431 mActivity.startActivityForResult(intent, AUTOFILL_SETUP);
2432 }
Michael Kolb8233fac2010-10-26 16:08:53 -07002433}