blob: 2ccc932874e4b09bcaacc8b8188e5178f19dbb55 [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
Michael Kolb8233fac2010-10-26 16:08:53 -070019import android.app.Activity;
20import android.app.DownloadManager;
21import android.app.SearchManager;
22import android.content.ClipboardManager;
23import android.content.ContentProvider;
24import android.content.ContentProviderClient;
25import android.content.ContentResolver;
John Reckd8c74522011-06-14 08:45:00 -070026import android.content.ContentUris;
Michael Kolb8233fac2010-10-26 16:08:53 -070027import android.content.ContentValues;
28import android.content.Context;
29import android.content.Intent;
30import android.content.pm.PackageManager;
31import android.content.pm.ResolveInfo;
32import android.content.res.Configuration;
John Reck30b065e2011-07-19 10:58:05 -070033import android.content.res.TypedArray;
Leon Scroggins1961ed22010-12-07 15:22:21 -050034import android.database.ContentObserver;
Michael Kolb8233fac2010-10-26 16:08:53 -070035import android.database.Cursor;
36import android.database.sqlite.SQLiteDatabase;
Michael Kolb8233fac2010-10-26 16:08:53 -070037import android.graphics.Bitmap;
38import android.graphics.Canvas;
Michael Kolb8233fac2010-10-26 16:08:53 -070039import android.net.Uri;
40import android.net.http.SslError;
41import android.os.AsyncTask;
42import android.os.Bundle;
43import android.os.Handler;
44import android.os.Message;
45import android.os.PowerManager;
46import android.os.PowerManager.WakeLock;
Ben Murdoch8029a772010-11-16 11:58:21 +000047import android.preference.PreferenceActivity;
Michael Kolb8233fac2010-10-26 16:08:53 -070048import android.provider.Browser;
49import android.provider.BrowserContract;
Michael Kolb8233fac2010-10-26 16:08:53 -070050import android.provider.BrowserContract.Images;
51import android.provider.ContactsContract;
52import android.provider.ContactsContract.Intents.Insert;
Michael Kolbcfa3af52010-12-14 10:36:11 -080053import android.speech.RecognizerIntent;
Michael Kolb8233fac2010-10-26 16:08:53 -070054import android.text.TextUtils;
55import android.util.Log;
John Recka00cbbd2010-12-16 12:38:19 -080056import android.util.Patterns;
Michael Kolb8233fac2010-10-26 16:08:53 -070057import android.view.ActionMode;
58import android.view.ContextMenu;
59import android.view.ContextMenu.ContextMenuInfo;
60import android.view.Gravity;
61import android.view.KeyEvent;
Michael Kolb8233fac2010-10-26 16:08:53 -070062import android.view.Menu;
63import android.view.MenuInflater;
64import android.view.MenuItem;
65import android.view.MenuItem.OnMenuItemClickListener;
Michael Kolbc3af0672011-08-09 10:24:41 -070066import android.view.MotionEvent;
Michael Kolb8233fac2010-10-26 16:08:53 -070067import android.view.View;
68import android.webkit.CookieManager;
69import android.webkit.CookieSyncManager;
70import android.webkit.HttpAuthHandler;
71import android.webkit.SslErrorHandler;
72import android.webkit.ValueCallback;
73import android.webkit.WebChromeClient;
74import android.webkit.WebIconDatabase;
75import android.webkit.WebSettings;
76import android.webkit.WebView;
Leon Scrogginsac993842011-02-02 12:54:07 -050077import android.widget.Toast;
Michael Kolb8233fac2010-10-26 16:08:53 -070078
Michael Kolb4bd767d2011-05-27 11:33:55 -070079import com.android.browser.IntentHandler.UrlData;
John Reck2bc80422011-06-30 15:11:49 -070080import com.android.browser.UI.ComboViews;
Michael Kolb4bd767d2011-05-27 11:33:55 -070081import com.android.browser.UI.DropdownChangeListener;
82import com.android.browser.provider.BrowserProvider;
John Reck1cf4b792011-07-26 10:22:22 -070083import com.android.browser.provider.BrowserProvider2.Thumbnails;
John Reck8cc92352011-07-06 17:41:52 -070084import com.android.browser.provider.SnapshotProvider.Snapshots;
Michael Kolb4bd767d2011-05-27 11:33:55 -070085import com.android.browser.search.SearchEngine;
86import com.android.common.Search;
87
Michael Kolb8233fac2010-10-26 16:08:53 -070088import java.io.ByteArrayOutputStream;
Michael Kolb8233fac2010-10-26 16:08:53 -070089import java.net.URLEncoder;
John Reck1cf4b792011-07-26 10:22:22 -070090import java.util.ArrayList;
Michael Kolb8233fac2010-10-26 16:08:53 -070091import java.util.Calendar;
92import java.util.HashMap;
Michael Kolb1bf23132010-11-19 12:55:12 -080093import java.util.List;
John Reck26b18322011-06-21 13:08:58 -070094import java.util.Map;
Michael Kolb8233fac2010-10-26 16:08:53 -070095
96/**
97 * Controller for browser
98 */
99public class Controller
100 implements WebViewController, UiController {
101
102 private static final String LOGTAG = "Controller";
Michael Kolbcfa3af52010-12-14 10:36:11 -0800103 private static final String SEND_APP_ID_EXTRA =
104 "android.speech.extras.SEND_APPLICATION_ID_EXTRA";
Michael Kolba4261fd2011-05-05 11:27:37 -0700105 private static final String INCOGNITO_URI = "browser:incognito";
Michael Kolbcfa3af52010-12-14 10:36:11 -0800106
Michael Kolb8233fac2010-10-26 16:08:53 -0700107
108 // public message ids
109 public final static int LOAD_URL = 1001;
110 public final static int STOP_LOAD = 1002;
111
112 // Message Ids
113 private static final int FOCUS_NODE_HREF = 102;
114 private static final int RELEASE_WAKELOCK = 107;
115
116 static final int UPDATE_BOOKMARK_THUMBNAIL = 108;
117
118 private static final int OPEN_BOOKMARKS = 201;
119
120 private static final int EMPTY_MENU = -1;
121
Michael Kolb8233fac2010-10-26 16:08:53 -0700122 // activity requestCode
John Reckd3e4d5b2011-07-13 15:48:43 -0700123 final static int COMBO_VIEW = 1;
Michael Kolb8233fac2010-10-26 16:08:53 -0700124 final static int PREFERENCES_PAGE = 3;
125 final static int FILE_SELECTED = 4;
Ben Murdoch8029a772010-11-16 11:58:21 +0000126 final static int AUTOFILL_SETUP = 5;
127
Michael Kolb8233fac2010-10-26 16:08:53 -0700128 private final static int WAKELOCK_TIMEOUT = 5 * 60 * 1000; // 5 minutes
129
130 // As the ids are dynamically created, we can't guarantee that they will
131 // be in sequence, so this static array maps ids to a window number.
132 final static private int[] WINDOW_SHORTCUT_ID_ARRAY =
133 { R.id.window_one_menu_id, R.id.window_two_menu_id,
134 R.id.window_three_menu_id, R.id.window_four_menu_id,
135 R.id.window_five_menu_id, R.id.window_six_menu_id,
136 R.id.window_seven_menu_id, R.id.window_eight_menu_id };
137
138 // "source" parameter for Google search through search key
139 final static String GOOGLE_SEARCH_SOURCE_SEARCHKEY = "browser-key";
140 // "source" parameter for Google search through simplily type
141 final static String GOOGLE_SEARCH_SOURCE_TYPE = "browser-type";
142
Guang Zhu9e78f512011-05-04 11:45:11 -0700143 // "no-crash-recovery" parameter in intetnt to suppress crash recovery
144 final static String NO_CRASH_RECOVERY = "no-crash-recovery";
145
John Reckd7dd9b22011-08-30 09:18:29 -0700146 // A bitmap that is re-used in createScreenshot as scratch space
147 private static Bitmap sThumbnailBitmap;
148
Michael Kolb8233fac2010-10-26 16:08:53 -0700149 private Activity mActivity;
150 private UI mUi;
151 private TabControl mTabControl;
152 private BrowserSettings mSettings;
153 private WebViewFactory mFactory;
154
155 private WakeLock mWakeLock;
156
157 private UrlHandler mUrlHandler;
158 private UploadHandler mUploadHandler;
159 private IntentHandler mIntentHandler;
Michael Kolb8233fac2010-10-26 16:08:53 -0700160 private PageDialogsHandler mPageDialogsHandler;
161 private NetworkStateHandler mNetworkHandler;
162
Ben Murdoch8029a772010-11-16 11:58:21 +0000163 private Message mAutoFillSetupMessage;
164
Michael Kolb8233fac2010-10-26 16:08:53 -0700165 private boolean mShouldShowErrorConsole;
166
167 private SystemAllowGeolocationOrigins mSystemAllowGeolocationOrigins;
168
169 // FIXME, temp address onPrepareMenu performance problem.
170 // When we move everything out of view, we should rewrite this.
171 private int mCurrentMenuState = 0;
172 private int mMenuState = R.id.MAIN_MENU;
173 private int mOldMenuState = EMPTY_MENU;
174 private Menu mCachedMenu;
175
Michael Kolb8233fac2010-10-26 16:08:53 -0700176 private boolean mMenuIsDown;
177
178 // For select and find, we keep track of the ActionMode so that
179 // finish() can be called as desired.
180 private ActionMode mActionMode;
181
182 /**
183 * Only meaningful when mOptionsMenuOpen is true. This variable keeps track
184 * of whether the configuration has changed. The first onMenuOpened call
185 * after a configuration change is simply a reopening of the same menu
186 * (i.e. mIconView did not change).
187 */
188 private boolean mConfigChanged;
189
190 /**
191 * Keeps track of whether the options menu is open. This is important in
192 * determining whether to show or hide the title bar overlay
193 */
194 private boolean mOptionsMenuOpen;
195
196 /**
197 * Whether or not the options menu is in its bigger, popup menu form. When
198 * true, we want the title bar overlay to be gone. When false, we do not.
199 * Only meaningful if mOptionsMenuOpen is true.
200 */
201 private boolean mExtendedMenuOpen;
202
203 private boolean mInLoad;
204
205 private boolean mActivityPaused = true;
206 private boolean mLoadStopped;
207
208 private Handler mHandler;
Leon Scroggins1961ed22010-12-07 15:22:21 -0500209 // Checks to see when the bookmarks database has changed, and updates the
210 // Tabs' notion of whether they represent bookmarked sites.
211 private ContentObserver mBookmarksObserver;
John Reck847b5322011-04-14 17:02:18 -0700212 private CrashRecoveryHandler mCrashRecoveryHandler;
Michael Kolb8233fac2010-10-26 16:08:53 -0700213
Michael Kolbc3af0672011-08-09 10:24:41 -0700214 private boolean mBlockEvents;
215
John Reckbc490d22011-07-22 15:04:59 -0700216 public Controller(Activity browser, boolean preloadCrashState) {
Michael Kolb8233fac2010-10-26 16:08:53 -0700217 mActivity = browser;
218 mSettings = BrowserSettings.getInstance();
219 mTabControl = new TabControl(this);
220 mSettings.setController(this);
John Reck378a4102011-06-09 16:23:01 -0700221 mCrashRecoveryHandler = CrashRecoveryHandler.initialize(this);
John Reckbc490d22011-07-22 15:04:59 -0700222 if (preloadCrashState) {
223 mCrashRecoveryHandler.preloadCrashState();
224 }
Michael Kolb14612442011-06-24 13:06:29 -0700225 mFactory = new BrowserWebViewFactory(browser);
Michael Kolb8233fac2010-10-26 16:08:53 -0700226
227 mUrlHandler = new UrlHandler(this);
228 mIntentHandler = new IntentHandler(mActivity, this);
Michael Kolb8233fac2010-10-26 16:08:53 -0700229 mPageDialogsHandler = new PageDialogsHandler(mActivity, this);
230
Michael Kolb8233fac2010-10-26 16:08:53 -0700231 startHandler();
Leon Scroggins1961ed22010-12-07 15:22:21 -0500232 mBookmarksObserver = new ContentObserver(mHandler) {
233 @Override
234 public void onChange(boolean selfChange) {
235 int size = mTabControl.getTabCount();
236 for (int i = 0; i < size; i++) {
237 mTabControl.getTab(i).updateBookmarkedStatus();
238 }
239 }
240
241 };
242 browser.getContentResolver().registerContentObserver(
243 BrowserContract.Bookmarks.CONTENT_URI, true, mBookmarksObserver);
Michael Kolb8233fac2010-10-26 16:08:53 -0700244
245 mNetworkHandler = new NetworkStateHandler(mActivity, this);
246 // Start watching the default geolocation permissions
247 mSystemAllowGeolocationOrigins =
248 new SystemAllowGeolocationOrigins(mActivity.getApplicationContext());
249 mSystemAllowGeolocationOrigins.start();
250
John Reckaf262e72011-07-25 13:55:44 -0700251 openIconDatabase();
Michael Kolb8233fac2010-10-26 16:08:53 -0700252 }
253
Patrick Scott7d50a932011-02-04 09:27:26 -0500254 void start(final Bundle icicle, final Intent intent) {
Guang Zhu9e78f512011-05-04 11:45:11 -0700255 boolean noCrashRecovery = intent.getBooleanExtra(NO_CRASH_RECOVERY, false);
256 if (icicle != null || noCrashRecovery) {
John Reck847b5322011-04-14 17:02:18 -0700257 doStart(icicle, intent);
258 } else {
259 mCrashRecoveryHandler.startRecovery(intent);
260 }
261 }
262
263 void doStart(final Bundle icicle, final Intent intent) {
Michael Kolb8233fac2010-10-26 16:08:53 -0700264 // Unless the last browser usage was within 24 hours, destroy any
265 // remaining incognito tabs.
266
267 Calendar lastActiveDate = icicle != null ?
268 (Calendar) icicle.getSerializable("lastActiveDate") : null;
269 Calendar today = Calendar.getInstance();
270 Calendar yesterday = Calendar.getInstance();
271 yesterday.add(Calendar.DATE, -1);
272
Patrick Scott7d50a932011-02-04 09:27:26 -0500273 final boolean restoreIncognitoTabs = !(lastActiveDate == null
Michael Kolb8233fac2010-10-26 16:08:53 -0700274 || lastActiveDate.before(yesterday)
Michael Kolb1bf23132010-11-19 12:55:12 -0800275 || lastActiveDate.after(today));
Michael Kolb8233fac2010-10-26 16:08:53 -0700276
Patrick Scott7d50a932011-02-04 09:27:26 -0500277 // Find out if we will restore any state and remember the tab.
Michael Kolbc831b632011-05-11 09:30:34 -0700278 final long currentTabId =
Patrick Scott7d50a932011-02-04 09:27:26 -0500279 mTabControl.canRestoreState(icicle, restoreIncognitoTabs);
Kristian Monsen2cd97012010-12-07 11:11:40 +0000280
Michael Kolbc831b632011-05-11 09:30:34 -0700281 if (currentTabId == -1) {
Patrick Scott7d50a932011-02-04 09:27:26 -0500282 // Not able to restore so we go ahead and clear session cookies. We
283 // must do this before trying to login the user as we don't want to
284 // clear any session cookies set during login.
285 CookieManager.getInstance().removeSessionCookie();
286 }
287
Patrick Scottd43e75a2011-03-14 14:47:23 -0400288 GoogleAccountLogin.startLoginIfNeeded(mActivity,
Patrick Scott7d50a932011-02-04 09:27:26 -0500289 new Runnable() {
290 @Override public void run() {
Michael Kolbc831b632011-05-11 09:30:34 -0700291 onPreloginFinished(icicle, intent, currentTabId, restoreIncognitoTabs);
Patrick Scott7d50a932011-02-04 09:27:26 -0500292 }
293 });
294 }
295
Michael Kolbc831b632011-05-11 09:30:34 -0700296 private void onPreloginFinished(Bundle icicle, Intent intent, long currentTabId,
Patrick Scott7d50a932011-02-04 09:27:26 -0500297 boolean restoreIncognitoTabs) {
Michael Kolbc831b632011-05-11 09:30:34 -0700298 if (currentTabId == -1) {
John Reck1cf4b792011-07-26 10:22:22 -0700299 BackgroundHandler.execute(new PruneThumbnails(mActivity, null));
Michael Kolb8233fac2010-10-26 16:08:53 -0700300 final Bundle extra = intent.getExtras();
301 // Create an initial tab.
302 // If the intent is ACTION_VIEW and data is not null, the Browser is
303 // invoked to view the content by another application. In this case,
304 // the tab will be close when exit.
Michael Kolb14612442011-06-24 13:06:29 -0700305 UrlData urlData = IntentHandler.getUrlDataFromIntent(intent);
Michael Kolb7bcafde2011-05-09 13:55:59 -0700306 Tab t = null;
307 if (urlData.isEmpty()) {
308 t = openTabToHomePage();
309 } else {
310 t = openTab(urlData);
311 }
312 if (t != null) {
313 t.setAppId(intent.getStringExtra(Browser.EXTRA_APPLICATION_ID));
314 }
Michael Kolb8233fac2010-10-26 16:08:53 -0700315 WebView webView = t.getWebView();
316 if (extra != null) {
317 int scale = extra.getInt(Browser.INITIAL_ZOOM_LEVEL, 0);
318 if (scale > 0 && scale <= 1000) {
319 webView.setInitialScale(scale);
320 }
321 }
John Reckd8c74522011-06-14 08:45:00 -0700322 mUi.updateTabs(mTabControl.getTabs());
Michael Kolb8233fac2010-10-26 16:08:53 -0700323 } else {
Michael Kolbc831b632011-05-11 09:30:34 -0700324 mTabControl.restoreState(icicle, currentTabId, restoreIncognitoTabs,
Patrick Scott7d50a932011-02-04 09:27:26 -0500325 mUi.needsRestoreAllTabs());
John Reck1cf4b792011-07-26 10:22:22 -0700326 List<Tab> tabs = mTabControl.getTabs();
327 ArrayList<Long> restoredTabs = new ArrayList<Long>(tabs.size());
328 for (Tab t : tabs) {
329 restoredTabs.add(t.getId());
330 }
331 BackgroundHandler.execute(new PruneThumbnails(mActivity, restoredTabs));
John Reck52be4782011-08-26 15:37:29 -0700332 if (tabs.size() == 0) {
333 openTabToHomePage();
334 }
John Reck1cf4b792011-07-26 10:22:22 -0700335 mUi.updateTabs(tabs);
Michael Kolb8233fac2010-10-26 16:08:53 -0700336 // TabControl.restoreState() will create a new tab even if
337 // restoring the state fails.
338 setActiveTab(mTabControl.getCurrentTab());
John Reckdb22ec42011-06-29 11:31:24 -0700339 // Handle the intent
340 mIntentHandler.onNewIntent(intent);
Michael Kolb8233fac2010-10-26 16:08:53 -0700341 }
Michael Kolb8233fac2010-10-26 16:08:53 -0700342 // Read JavaScript flags if it exists.
John Reck35e9dd62011-04-25 09:01:54 -0700343 String jsFlags = getSettings().getJsEngineFlags();
Michael Kolb8233fac2010-10-26 16:08:53 -0700344 if (jsFlags.trim().length() != 0) {
345 getCurrentWebView().setJsFlags(jsFlags);
346 }
John Reck439c9a52010-12-14 10:04:39 -0800347 if (BrowserActivity.ACTION_SHOW_BOOKMARKS.equals(intent.getAction())) {
348 bookmarksOrHistoryPicker(false);
349 }
Michael Kolb8233fac2010-10-26 16:08:53 -0700350 }
351
John Reck1cf4b792011-07-26 10:22:22 -0700352 private static class PruneThumbnails implements Runnable {
353 private Context mContext;
354 private List<Long> mIds;
355
356 PruneThumbnails(Context context, List<Long> preserveIds) {
357 mContext = context.getApplicationContext();
358 mIds = preserveIds;
359 }
360
361 @Override
362 public void run() {
363 ContentResolver cr = mContext.getContentResolver();
364 if (mIds == null || mIds.size() == 0) {
365 cr.delete(Thumbnails.CONTENT_URI, null, null);
366 } else {
367 int length = mIds.size();
368 StringBuilder where = new StringBuilder();
369 where.append(Thumbnails._ID);
370 where.append(" not in (");
371 for (int i = 0; i < length; i++) {
372 where.append(mIds.get(i));
373 if (i < (length - 1)) {
374 where.append(",");
375 }
376 }
377 where.append(")");
378 cr.delete(Thumbnails.CONTENT_URI, where.toString(), null);
379 }
380 }
381
382 }
383
Michael Kolb1514bb72010-11-22 09:11:48 -0800384 @Override
385 public WebViewFactory getWebViewFactory() {
Michael Kolb8233fac2010-10-26 16:08:53 -0700386 return mFactory;
387 }
388
389 @Override
Michael Kolba713ec82010-11-29 17:27:06 -0800390 public void onSetWebView(Tab tab, WebView view) {
391 mUi.onSetWebView(tab, view);
392 }
393
394 @Override
Michael Kolb1514bb72010-11-22 09:11:48 -0800395 public void createSubWindow(Tab tab) {
396 endActionMode();
397 WebView mainView = tab.getWebView();
398 WebView subView = mFactory.createWebView((mainView == null)
399 ? false
400 : mainView.isPrivateBrowsingEnabled());
401 mUi.createSubWindow(tab, subView);
402 }
403
404 @Override
Michael Kolb14612442011-06-24 13:06:29 -0700405 public Context getContext() {
406 return mActivity;
407 }
408
409 @Override
Michael Kolb8233fac2010-10-26 16:08:53 -0700410 public Activity getActivity() {
411 return mActivity;
412 }
413
414 void setUi(UI ui) {
415 mUi = ui;
416 }
417
418 BrowserSettings getSettings() {
419 return mSettings;
420 }
421
422 IntentHandler getIntentHandler() {
423 return mIntentHandler;
424 }
425
426 @Override
427 public UI getUi() {
428 return mUi;
429 }
430
431 int getMaxTabs() {
432 return mActivity.getResources().getInteger(R.integer.max_tabs);
433 }
434
435 @Override
436 public TabControl getTabControl() {
437 return mTabControl;
438 }
439
Michael Kolb1bf23132010-11-19 12:55:12 -0800440 @Override
441 public List<Tab> getTabs() {
442 return mTabControl.getTabs();
443 }
444
John Reckaf262e72011-07-25 13:55:44 -0700445 // Open the icon database.
446 private void openIconDatabase() {
447 // We have to call getInstance on the UI thread
448 final WebIconDatabase instance = WebIconDatabase.getInstance();
449 BackgroundHandler.execute(new Runnable() {
Ben Murdoch9446b932010-11-25 16:20:14 +0000450
John Reckaf262e72011-07-25 13:55:44 -0700451 @Override
452 public void run() {
453 instance.open(mActivity.getDir("icons", 0).getPath());
Michael Kolb8233fac2010-10-26 16:08:53 -0700454 }
John Reckaf262e72011-07-25 13:55:44 -0700455 });
Michael Kolb8233fac2010-10-26 16:08:53 -0700456 }
457
458 private void startHandler() {
459 mHandler = new Handler() {
460
461 @Override
462 public void handleMessage(Message msg) {
463 switch (msg.what) {
464 case OPEN_BOOKMARKS:
465 bookmarksOrHistoryPicker(false);
466 break;
467 case FOCUS_NODE_HREF:
468 {
469 String url = (String) msg.getData().get("url");
470 String title = (String) msg.getData().get("title");
Cary Clark043c2d62010-12-15 11:19:39 -0500471 String src = (String) msg.getData().get("src");
472 if (url == "") url = src; // use image if no anchor
Michael Kolb8233fac2010-10-26 16:08:53 -0700473 if (TextUtils.isEmpty(url)) {
474 break;
475 }
476 HashMap focusNodeMap = (HashMap) msg.obj;
477 WebView view = (WebView) focusNodeMap.get("webview");
478 // Only apply the action if the top window did not change.
479 if (getCurrentTopWebView() != view) {
480 break;
481 }
482 switch (msg.arg1) {
483 case R.id.open_context_menu_id:
John Reck26b18322011-06-21 13:08:58 -0700484 loadUrlFromContext(url);
Michael Kolb8233fac2010-10-26 16:08:53 -0700485 break;
Cary Clark043c2d62010-12-15 11:19:39 -0500486 case R.id.view_image_context_menu_id:
John Reck26b18322011-06-21 13:08:58 -0700487 loadUrlFromContext(src);
Cary Clark043c2d62010-12-15 11:19:39 -0500488 break;
Leon Scroggins026f2542010-11-22 13:26:12 -0500489 case R.id.open_newtab_context_menu_id:
490 final Tab parent = mTabControl.getCurrentTab();
John Reck5949c662011-05-27 09:52:29 -0700491 openTab(url, parent,
492 !mSettings.openInBackground(), true);
Leon Scroggins026f2542010-11-22 13:26:12 -0500493 break;
Michael Kolb8233fac2010-10-26 16:08:53 -0700494 case R.id.copy_link_context_menu_id:
495 copy(url);
496 break;
497 case R.id.save_link_context_menu_id:
498 case R.id.download_context_menu_id:
Leon Scroggins63c02662010-11-18 15:16:27 -0500499 DownloadHandler.onDownloadStartNoStream(
Kristian Monsenbc5cc752011-03-02 13:14:03 +0000500 mActivity, url, null, null, null,
501 view.isPrivateBrowsingEnabled());
Michael Kolb8233fac2010-10-26 16:08:53 -0700502 break;
503 }
504 break;
505 }
506
507 case LOAD_URL:
John Reck26b18322011-06-21 13:08:58 -0700508 loadUrlFromContext((String) msg.obj);
Michael Kolb8233fac2010-10-26 16:08:53 -0700509 break;
510
511 case STOP_LOAD:
512 stopLoading();
513 break;
514
515 case RELEASE_WAKELOCK:
John Reckf57c0292011-07-21 18:15:39 -0700516 if (mWakeLock != null && mWakeLock.isHeld()) {
Michael Kolb8233fac2010-10-26 16:08:53 -0700517 mWakeLock.release();
518 // if we reach here, Browser should be still in the
519 // background loading after WAKELOCK_TIMEOUT (5-min).
520 // To avoid burning the battery, stop loading.
521 mTabControl.stopAllLoading();
522 }
523 break;
524
525 case UPDATE_BOOKMARK_THUMBNAIL:
John Reck34ef2672011-02-10 11:30:55 -0800526 Tab tab = (Tab) msg.obj;
527 if (tab != null) {
528 updateScreenshot(tab);
Michael Kolb8233fac2010-10-26 16:08:53 -0700529 }
530 break;
531 }
532 }
533 };
534
535 }
536
John Reckef654f12011-07-12 16:42:08 -0700537 @Override
Martijn Coenenb2f93552011-06-14 10:48:35 +0200538 public Tab getCurrentTab() {
539 return mTabControl.getCurrentTab();
540 }
541
Michael Kolbba99c5d2010-11-29 14:57:41 -0800542 @Override
543 public void shareCurrentPage() {
544 shareCurrentPage(mTabControl.getCurrentTab());
545 }
546
547 private void shareCurrentPage(Tab tab) {
548 if (tab != null) {
Michael Kolbba99c5d2010-11-29 14:57:41 -0800549 sharePage(mActivity, tab.getTitle(),
550 tab.getUrl(), tab.getFavicon(),
551 createScreenshot(tab.getWebView(),
552 getDesiredThumbnailWidth(mActivity),
553 getDesiredThumbnailHeight(mActivity)));
554 }
555 }
556
Michael Kolb8233fac2010-10-26 16:08:53 -0700557 /**
558 * Share a page, providing the title, url, favicon, and a screenshot. Uses
559 * an {@link Intent} to launch the Activity chooser.
560 * @param c Context used to launch a new Activity.
561 * @param title Title of the page. Stored in the Intent with
562 * {@link Intent#EXTRA_SUBJECT}
563 * @param url URL of the page. Stored in the Intent with
564 * {@link Intent#EXTRA_TEXT}
565 * @param favicon Bitmap of the favicon for the page. Stored in the Intent
566 * with {@link Browser#EXTRA_SHARE_FAVICON}
567 * @param screenshot Bitmap of a screenshot of the page. Stored in the
568 * Intent with {@link Browser#EXTRA_SHARE_SCREENSHOT}
569 */
570 static final void sharePage(Context c, String title, String url,
571 Bitmap favicon, Bitmap screenshot) {
572 Intent send = new Intent(Intent.ACTION_SEND);
573 send.setType("text/plain");
574 send.putExtra(Intent.EXTRA_TEXT, url);
575 send.putExtra(Intent.EXTRA_SUBJECT, title);
576 send.putExtra(Browser.EXTRA_SHARE_FAVICON, favicon);
577 send.putExtra(Browser.EXTRA_SHARE_SCREENSHOT, screenshot);
578 try {
579 c.startActivity(Intent.createChooser(send, c.getString(
580 R.string.choosertitle_sharevia)));
581 } catch(android.content.ActivityNotFoundException ex) {
582 // if no app handles it, do nothing
583 }
584 }
585
586 private void copy(CharSequence text) {
587 ClipboardManager cm = (ClipboardManager) mActivity
588 .getSystemService(Context.CLIPBOARD_SERVICE);
589 cm.setText(text);
590 }
591
592 // lifecycle
593
594 protected void onConfgurationChanged(Configuration config) {
595 mConfigChanged = true;
596 if (mPageDialogsHandler != null) {
597 mPageDialogsHandler.onConfigurationChanged(config);
598 }
599 mUi.onConfigurationChanged(config);
600 }
601
602 @Override
603 public void handleNewIntent(Intent intent) {
Michael Kolb59e232c2011-08-18 17:19:53 -0700604 if (!mUi.isWebShowing()) {
605 mUi.showWeb(false);
606 }
Michael Kolb8233fac2010-10-26 16:08:53 -0700607 mIntentHandler.onNewIntent(intent);
608 }
609
610 protected void onPause() {
Michael Kolb11fe02d2011-02-02 09:52:16 -0800611 if (mUi.isCustomViewShowing()) {
612 hideCustomView();
613 }
Michael Kolb8233fac2010-10-26 16:08:53 -0700614 if (mActivityPaused) {
615 Log.e(LOGTAG, "BrowserActivity is already paused.");
616 return;
617 }
Michael Kolb8233fac2010-10-26 16:08:53 -0700618 mActivityPaused = true;
Michael Kolb70976932010-11-30 11:34:01 -0800619 Tab tab = mTabControl.getCurrentTab();
620 if (tab != null) {
621 tab.pause();
622 if (!pauseWebViewTimers(tab)) {
John Reckf57c0292011-07-21 18:15:39 -0700623 if (mWakeLock == null) {
624 PowerManager pm = (PowerManager) mActivity
625 .getSystemService(Context.POWER_SERVICE);
626 mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "Browser");
627 }
Michael Kolb70976932010-11-30 11:34:01 -0800628 mWakeLock.acquire();
629 mHandler.sendMessageDelayed(mHandler
630 .obtainMessage(RELEASE_WAKELOCK), WAKELOCK_TIMEOUT);
631 }
Michael Kolb8233fac2010-10-26 16:08:53 -0700632 }
633 mUi.onPause();
634 mNetworkHandler.onPause();
635
636 WebView.disablePlatformNotifications();
Ben Murdoch015e1e32011-09-01 23:45:31 +0100637 NfcHandler.unregister(mActivity);
John Reckd7dd9b22011-08-30 09:18:29 -0700638 if (sThumbnailBitmap != null) {
639 sThumbnailBitmap.recycle();
640 sThumbnailBitmap = null;
641 }
Michael Kolb8233fac2010-10-26 16:08:53 -0700642 }
643
John Reck1cf4b792011-07-26 10:22:22 -0700644 void onSaveInstanceState(Bundle outState) {
Michael Kolb8233fac2010-10-26 16:08:53 -0700645 // the default implementation requires each view to have an id. As the
646 // browser handles the state itself and it doesn't use id for the views,
647 // don't call the default implementation. Otherwise it will trigger the
648 // warning like this, "couldn't save which view has focus because the
649 // focused view XXX has no id".
650
651 // Save all the tabs
John Reck1cf4b792011-07-26 10:22:22 -0700652 mTabControl.saveState(outState);
John Reck24f18262011-06-17 14:47:20 -0700653 if (!outState.isEmpty()) {
654 // Save time so that we know how old incognito tabs (if any) are.
655 outState.putSerializable("lastActiveDate", Calendar.getInstance());
656 }
Michael Kolb8233fac2010-10-26 16:08:53 -0700657 }
658
659 void onResume() {
660 if (!mActivityPaused) {
661 Log.e(LOGTAG, "BrowserActivity is already resumed.");
662 return;
663 }
Michael Kolb8233fac2010-10-26 16:08:53 -0700664 mActivityPaused = false;
Michael Kolb70976932010-11-30 11:34:01 -0800665 Tab current = mTabControl.getCurrentTab();
666 if (current != null) {
667 current.resume();
668 resumeWebViewTimers(current);
669 }
John Reckf57c0292011-07-21 18:15:39 -0700670 releaseWakeLock();
Martijn Coenenb2f93552011-06-14 10:48:35 +0200671
Michael Kolb8233fac2010-10-26 16:08:53 -0700672 mUi.onResume();
673 mNetworkHandler.onResume();
674 WebView.enablePlatformNotifications();
Ben Murdoch015e1e32011-09-01 23:45:31 +0100675 NfcHandler.register(mActivity, this);
Michael Kolb8233fac2010-10-26 16:08:53 -0700676 }
677
John Reckf57c0292011-07-21 18:15:39 -0700678 private void releaseWakeLock() {
679 if (mWakeLock != null && mWakeLock.isHeld()) {
680 mHandler.removeMessages(RELEASE_WAKELOCK);
681 mWakeLock.release();
682 }
683 }
684
Michael Kolb70976932010-11-30 11:34:01 -0800685 /**
Michael Kolbba99c5d2010-11-29 14:57:41 -0800686 * resume all WebView timers using the WebView instance of the given tab
Michael Kolb70976932010-11-30 11:34:01 -0800687 * @param tab guaranteed non-null
688 */
689 private void resumeWebViewTimers(Tab tab) {
Michael Kolb8233fac2010-10-26 16:08:53 -0700690 boolean inLoad = tab.inPageLoad();
691 if ((!mActivityPaused && !inLoad) || (mActivityPaused && inLoad)) {
692 CookieSyncManager.getInstance().startSync();
693 WebView w = tab.getWebView();
Mathew Inwoode1dbb952011-07-08 17:27:38 +0100694 WebViewTimersControl.getInstance().onBrowserActivityResume(w);
Michael Kolb8233fac2010-10-26 16:08:53 -0700695 }
696 }
697
Michael Kolb70976932010-11-30 11:34:01 -0800698 /**
699 * Pause all WebView timers using the WebView of the given tab
700 * @param tab
701 * @return true if the timers are paused or tab is null
702 */
703 private boolean pauseWebViewTimers(Tab tab) {
704 if (tab == null) {
705 return true;
706 } else if (!tab.inPageLoad()) {
Michael Kolb8233fac2010-10-26 16:08:53 -0700707 CookieSyncManager.getInstance().stopSync();
Mathew Inwoode1dbb952011-07-08 17:27:38 +0100708 WebViewTimersControl.getInstance().onBrowserActivityPause(getCurrentWebView());
Michael Kolb8233fac2010-10-26 16:08:53 -0700709 return true;
Michael Kolb8233fac2010-10-26 16:08:53 -0700710 }
Michael Kolb70976932010-11-30 11:34:01 -0800711 return false;
Michael Kolb8233fac2010-10-26 16:08:53 -0700712 }
713
714 void onDestroy() {
John Reck38b4bf52011-02-22 14:39:34 -0800715 if (mUploadHandler != null && !mUploadHandler.handled()) {
Michael Kolb8233fac2010-10-26 16:08:53 -0700716 mUploadHandler.onResult(Activity.RESULT_CANCELED, null);
717 mUploadHandler = null;
718 }
719 if (mTabControl == null) return;
720 mUi.onDestroy();
721 // Remove the current tab and sub window
722 Tab t = mTabControl.getCurrentTab();
723 if (t != null) {
724 dismissSubWindow(t);
725 removeTab(t);
726 }
Leon Scroggins1961ed22010-12-07 15:22:21 -0500727 mActivity.getContentResolver().unregisterContentObserver(mBookmarksObserver);
Michael Kolb8233fac2010-10-26 16:08:53 -0700728 // Destroy all the tabs
729 mTabControl.destroy();
730 WebIconDatabase.getInstance().close();
731 // Stop watching the default geolocation permissions
732 mSystemAllowGeolocationOrigins.stop();
733 mSystemAllowGeolocationOrigins = null;
734 }
735
736 protected boolean isActivityPaused() {
737 return mActivityPaused;
738 }
739
740 protected void onLowMemory() {
741 mTabControl.freeMemory();
742 }
743
744 @Override
745 public boolean shouldShowErrorConsole() {
746 return mShouldShowErrorConsole;
747 }
748
749 protected void setShouldShowErrorConsole(boolean show) {
750 if (show == mShouldShowErrorConsole) {
751 // Nothing to do.
752 return;
753 }
754 mShouldShowErrorConsole = show;
755 Tab t = mTabControl.getCurrentTab();
756 if (t == null) {
757 // There is no current tab so we cannot toggle the error console
758 return;
759 }
760 mUi.setShouldShowErrorConsole(t, show);
761 }
762
763 @Override
764 public void stopLoading() {
765 mLoadStopped = true;
766 Tab tab = mTabControl.getCurrentTab();
Michael Kolb8233fac2010-10-26 16:08:53 -0700767 WebView w = getCurrentTopWebView();
768 w.stopLoading();
Michael Kolb8233fac2010-10-26 16:08:53 -0700769 mUi.onPageStopped(tab);
770 }
771
772 boolean didUserStopLoading() {
773 return mLoadStopped;
774 }
775
776 // WebViewController
777
778 @Override
John Reck324d4402011-01-11 16:56:42 -0800779 public void onPageStarted(Tab tab, WebView view, Bitmap favicon) {
Michael Kolb8233fac2010-10-26 16:08:53 -0700780
781 // We've started to load a new page. If there was a pending message
782 // to save a screenshot then we will now take the new page and save
783 // an incorrect screenshot. Therefore, remove any pending thumbnail
784 // messages from the queue.
785 mHandler.removeMessages(Controller.UPDATE_BOOKMARK_THUMBNAIL,
John Reck34ef2672011-02-10 11:30:55 -0800786 tab);
Michael Kolb8233fac2010-10-26 16:08:53 -0700787
788 // reset sync timer to avoid sync starts during loading a page
789 CookieSyncManager.getInstance().resetSync();
790
791 if (!mNetworkHandler.isNetworkUp()) {
792 view.setNetworkAvailable(false);
793 }
794
795 // when BrowserActivity just starts, onPageStarted may be called before
796 // onResume as it is triggered from onCreate. Call resumeWebViewTimers
797 // to start the timer. As we won't switch tabs while an activity is in
798 // pause state, we can ensure calling resume and pause in pair.
799 if (mActivityPaused) {
Michael Kolb70976932010-11-30 11:34:01 -0800800 resumeWebViewTimers(tab);
Michael Kolb8233fac2010-10-26 16:08:53 -0700801 }
802 mLoadStopped = false;
803 if (!mNetworkHandler.isNetworkUp()) {
804 mNetworkHandler.createAndShowNetworkDialog();
805 }
806 endActionMode();
807
John Reck30c714c2010-12-16 17:30:34 -0800808 mUi.onTabDataChanged(tab);
Michael Kolb8233fac2010-10-26 16:08:53 -0700809
John Reck324d4402011-01-11 16:56:42 -0800810 String url = tab.getUrl();
Michael Kolb8233fac2010-10-26 16:08:53 -0700811 // update the bookmark database for favicon
812 maybeUpdateFavicon(tab, null, url, favicon);
813
814 Performance.tracePageStart(url);
815
816 // Performance probe
817 if (false) {
818 Performance.onPageStarted();
819 }
820
821 }
822
823 @Override
John Reck324d4402011-01-11 16:56:42 -0800824 public void onPageFinished(Tab tab) {
John Reck30c714c2010-12-16 17:30:34 -0800825 mUi.onTabDataChanged(tab);
John Reck324d4402011-01-11 16:56:42 -0800826 if (!tab.isPrivateBrowsingEnabled()
John Reckd8c74522011-06-14 08:45:00 -0700827 && !TextUtils.isEmpty(tab.getUrl())
828 && !tab.isSnapshot()) {
John Recka1696282011-07-08 14:10:37 -0700829 // Only update the bookmark screenshot if the user did not
830 // cancel the load early and there is not already
831 // a pending update for the tab.
Michael Kolb8233fac2010-10-26 16:08:53 -0700832 if (tab.inForeground() && !didUserStopLoading()
833 || !tab.inForeground()) {
John Recka1696282011-07-08 14:10:37 -0700834 if (!mHandler.hasMessages(UPDATE_BOOKMARK_THUMBNAIL, tab)) {
835 mHandler.sendMessageDelayed(mHandler.obtainMessage(
836 UPDATE_BOOKMARK_THUMBNAIL, 0, 0, tab),
837 500);
838 }
Michael Kolb8233fac2010-10-26 16:08:53 -0700839 }
840 }
841 // pause the WebView timer and release the wake lock if it is finished
842 // while BrowserActivity is in pause state.
Michael Kolb70976932010-11-30 11:34:01 -0800843 if (mActivityPaused && pauseWebViewTimers(tab)) {
John Reckf57c0292011-07-21 18:15:39 -0700844 releaseWakeLock();
Michael Kolb8233fac2010-10-26 16:08:53 -0700845 }
Martijn Coenenb2f93552011-06-14 10:48:35 +0200846
Michael Kolb8233fac2010-10-26 16:08:53 -0700847 // Performance probe
848 if (false) {
John Reck324d4402011-01-11 16:56:42 -0800849 Performance.onPageFinished(tab.getUrl());
Michael Kolb8233fac2010-10-26 16:08:53 -0700850 }
851
852 Performance.tracePageFinished();
853 }
854
855 @Override
John Reck30c714c2010-12-16 17:30:34 -0800856 public void onProgressChanged(Tab tab) {
John Reck6c2e2f32011-08-22 13:41:23 -0700857 mCrashRecoveryHandler.backupState();
John Reck30c714c2010-12-16 17:30:34 -0800858 int newProgress = tab.getLoadProgress();
Michael Kolb8233fac2010-10-26 16:08:53 -0700859
860 if (newProgress == 100) {
861 CookieSyncManager.getInstance().sync();
862 // onProgressChanged() may continue to be called after the main
863 // frame has finished loading, as any remaining sub frames continue
864 // to load. We'll only get called once though with newProgress as
865 // 100 when everything is loaded. (onPageFinished is called once
866 // when the main frame completes loading regardless of the state of
867 // any sub frames so calls to onProgressChanges may continue after
868 // onPageFinished has executed)
869 if (mInLoad) {
870 mInLoad = false;
871 updateInLoadMenuItems(mCachedMenu);
872 }
873 } else {
874 if (!mInLoad) {
875 // onPageFinished may have already been called but a subframe is
876 // still loading and updating the progress. Reset mInLoad and
877 // update the menu items.
878 mInLoad = true;
879 updateInLoadMenuItems(mCachedMenu);
880 }
881 }
John Reck30c714c2010-12-16 17:30:34 -0800882 mUi.onProgressChanged(tab);
883 }
884
885 @Override
886 public void onUpdatedLockIcon(Tab tab) {
887 mUi.onTabDataChanged(tab);
Michael Kolb8233fac2010-10-26 16:08:53 -0700888 }
889
890 @Override
891 public void onReceivedTitle(Tab tab, final String title) {
John Reck30c714c2010-12-16 17:30:34 -0800892 mUi.onTabDataChanged(tab);
John Reck49a603c2011-03-03 09:33:05 -0800893 final String pageUrl = tab.getOriginalUrl();
John Reck324d4402011-01-11 16:56:42 -0800894 if (TextUtils.isEmpty(pageUrl) || pageUrl.length()
Michael Kolb8233fac2010-10-26 16:08:53 -0700895 >= SQLiteDatabase.SQLITE_MAX_LIKE_PATTERN_LENGTH) {
896 return;
897 }
898 // Update the title in the history database if not in private browsing mode
899 if (!tab.isPrivateBrowsingEnabled()) {
John Reckf57c0292011-07-21 18:15:39 -0700900 DataController.getInstance(mActivity).updateHistoryTitle(pageUrl, title);
Michael Kolb8233fac2010-10-26 16:08:53 -0700901 }
902 }
903
904 @Override
905 public void onFavicon(Tab tab, WebView view, Bitmap icon) {
John Reck30c714c2010-12-16 17:30:34 -0800906 mUi.onTabDataChanged(tab);
Michael Kolb8233fac2010-10-26 16:08:53 -0700907 maybeUpdateFavicon(tab, view.getOriginalUrl(), view.getUrl(), icon);
908 }
909
910 @Override
Michael Kolb18eb3772010-12-10 14:29:51 -0800911 public boolean shouldOverrideUrlLoading(Tab tab, WebView view, String url) {
912 return mUrlHandler.shouldOverrideUrlLoading(tab, view, url);
Michael Kolb8233fac2010-10-26 16:08:53 -0700913 }
914
915 @Override
916 public boolean shouldOverrideKeyEvent(KeyEvent event) {
917 if (mMenuIsDown) {
918 // only check shortcut key when MENU is held
919 return mActivity.getWindow().isShortcutKey(event.getKeyCode(),
920 event);
921 } else {
922 return false;
923 }
924 }
925
926 @Override
927 public void onUnhandledKeyEvent(KeyEvent event) {
928 if (!isActivityPaused()) {
929 if (event.getAction() == KeyEvent.ACTION_DOWN) {
930 mActivity.onKeyDown(event.getKeyCode(), event);
931 } else {
932 mActivity.onKeyUp(event.getKeyCode(), event);
933 }
934 }
935 }
936
937 @Override
John Reck324d4402011-01-11 16:56:42 -0800938 public void doUpdateVisitedHistory(Tab tab, boolean isReload) {
Michael Kolb8233fac2010-10-26 16:08:53 -0700939 // Don't save anything in private browsing mode
940 if (tab.isPrivateBrowsingEnabled()) return;
John Reck49a603c2011-03-03 09:33:05 -0800941 String url = tab.getOriginalUrl();
Michael Kolb8233fac2010-10-26 16:08:53 -0700942
John Reck324d4402011-01-11 16:56:42 -0800943 if (TextUtils.isEmpty(url)
944 || url.regionMatches(true, 0, "about:", 0, 6)) {
Michael Kolb8233fac2010-10-26 16:08:53 -0700945 return;
946 }
John Reckf57c0292011-07-21 18:15:39 -0700947 DataController.getInstance(mActivity).updateVisitedHistory(url);
John Reck6c2e2f32011-08-22 13:41:23 -0700948 mCrashRecoveryHandler.backupState();
Michael Kolb8233fac2010-10-26 16:08:53 -0700949 }
950
951 @Override
952 public void getVisitedHistory(final ValueCallback<String[]> callback) {
953 AsyncTask<Void, Void, String[]> task =
954 new AsyncTask<Void, Void, String[]>() {
955 @Override
956 public String[] doInBackground(Void... unused) {
957 return Browser.getVisitedHistory(mActivity.getContentResolver());
958 }
959 @Override
960 public void onPostExecute(String[] result) {
961 callback.onReceiveValue(result);
962 }
963 };
964 task.execute();
965 }
966
967 @Override
968 public void onReceivedHttpAuthRequest(Tab tab, WebView view,
969 final HttpAuthHandler handler, final String host,
970 final String realm) {
971 String username = null;
972 String password = null;
973
974 boolean reuseHttpAuthUsernamePassword
975 = handler.useHttpAuthUsernamePassword();
976
977 if (reuseHttpAuthUsernamePassword && view != null) {
978 String[] credentials = view.getHttpAuthUsernamePassword(host, realm);
979 if (credentials != null && credentials.length == 2) {
980 username = credentials[0];
981 password = credentials[1];
982 }
983 }
984
985 if (username != null && password != null) {
986 handler.proceed(username, password);
987 } else {
Ben Murdochfdd37112011-08-05 15:48:14 +0100988 if (tab.inForeground() && !handler.suppressDialog()) {
Michael Kolb8233fac2010-10-26 16:08:53 -0700989 mPageDialogsHandler.showHttpAuthentication(tab, handler, host, realm);
990 } else {
991 handler.cancel();
992 }
993 }
994 }
995
996 @Override
997 public void onDownloadStart(Tab tab, String url, String userAgent,
998 String contentDisposition, String mimetype, long contentLength) {
Kristian Monsenbc5cc752011-03-02 13:14:03 +0000999 WebView w = tab.getWebView();
Leon Scroggins63c02662010-11-18 15:16:27 -05001000 DownloadHandler.onDownloadStart(mActivity, url, userAgent,
Kristian Monsenbc5cc752011-03-02 13:14:03 +00001001 contentDisposition, mimetype, w.isPrivateBrowsingEnabled());
1002 if (w.copyBackForwardList().getSize() == 0) {
Michael Kolb8233fac2010-10-26 16:08:53 -07001003 // This Tab was opened for the sole purpose of downloading a
1004 // file. Remove it.
1005 if (tab == mTabControl.getCurrentTab()) {
1006 // In this case, the Tab is still on top.
1007 goBackOnePageOrQuit();
1008 } else {
1009 // In this case, it is not.
1010 closeTab(tab);
1011 }
1012 }
1013 }
1014
1015 @Override
1016 public Bitmap getDefaultVideoPoster() {
1017 return mUi.getDefaultVideoPoster();
1018 }
1019
1020 @Override
1021 public View getVideoLoadingProgressView() {
1022 return mUi.getVideoLoadingProgressView();
1023 }
1024
1025 @Override
1026 public void showSslCertificateOnError(WebView view, SslErrorHandler handler,
1027 SslError error) {
1028 mPageDialogsHandler.showSSLCertificateOnError(view, handler, error);
1029 }
1030
Patrick Scott92066772011-03-10 08:46:27 -05001031 @Override
1032 public void showAutoLogin(Tab tab) {
1033 assert tab.inForeground();
1034 // Update the title bar to show the auto-login request.
1035 mUi.showAutoLogin(tab);
1036 }
1037
1038 @Override
1039 public void hideAutoLogin(Tab tab) {
1040 assert tab.inForeground();
1041 mUi.hideAutoLogin(tab);
1042 }
1043
Michael Kolb8233fac2010-10-26 16:08:53 -07001044 // helper method
1045
1046 /*
1047 * Update the favorites icon if the private browsing isn't enabled and the
1048 * icon is valid.
1049 */
1050 private void maybeUpdateFavicon(Tab tab, final String originalUrl,
1051 final String url, Bitmap favicon) {
1052 if (favicon == null) {
1053 return;
1054 }
1055 if (!tab.isPrivateBrowsingEnabled()) {
1056 Bookmarks.updateFavicon(mActivity
1057 .getContentResolver(), originalUrl, url, favicon);
1058 }
1059 }
1060
Leon Scroggins4cd97792010-12-03 15:31:56 -05001061 @Override
1062 public void bookmarkedStatusHasChanged(Tab tab) {
John Recke969cc52010-12-21 17:24:43 -08001063 // TODO: Switch to using onTabDataChanged after b/3262950 is fixed
Leon Scroggins4cd97792010-12-03 15:31:56 -05001064 mUi.bookmarkedStatusHasChanged(tab);
1065 }
1066
Michael Kolb8233fac2010-10-26 16:08:53 -07001067 // end WebViewController
1068
1069 protected void pageUp() {
1070 getCurrentTopWebView().pageUp(false);
1071 }
1072
1073 protected void pageDown() {
1074 getCurrentTopWebView().pageDown(false);
1075 }
1076
1077 // callback from phone title bar
1078 public void editUrl() {
1079 if (mOptionsMenuOpen) mActivity.closeOptionsMenu();
Michael Kolbdc2ee1b2011-02-14 14:34:40 -08001080 mUi.editUrl(false);
Michael Kolb8233fac2010-10-26 16:08:53 -07001081 }
1082
Michael Kolbcfa3af52010-12-14 10:36:11 -08001083 public void startVoiceSearch() {
1084 Intent intent = new Intent(RecognizerIntent.ACTION_WEB_SEARCH);
1085 intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL,
1086 RecognizerIntent.LANGUAGE_MODEL_WEB_SEARCH);
1087 intent.putExtra(RecognizerIntent.EXTRA_CALLING_PACKAGE,
1088 mActivity.getComponentName().flattenToString());
1089 intent.putExtra(SEND_APP_ID_EXTRA, false);
Michael Kolb17c4eba2011-01-10 13:10:07 -08001090 intent.putExtra(RecognizerIntent.EXTRA_WEB_SEARCH_ONLY, true);
Michael Kolbcfa3af52010-12-14 10:36:11 -08001091 mActivity.startActivity(intent);
1092 }
1093
Michael Kolb11d19782011-03-20 10:17:40 -07001094 @Override
1095 public void activateVoiceSearchMode(String title, List<String> results) {
1096 mUi.showVoiceTitleBar(title, results);
Michael Kolb8233fac2010-10-26 16:08:53 -07001097 }
1098
1099 public void revertVoiceSearchMode(Tab tab) {
1100 mUi.revertVoiceTitleBar(tab);
1101 }
1102
Michael Kolb736990c2011-03-20 10:01:20 -07001103 public boolean supportsVoiceSearch() {
John Reck35e9dd62011-04-25 09:01:54 -07001104 SearchEngine searchEngine = getSettings().getSearchEngine();
Michael Kolb736990c2011-03-20 10:01:20 -07001105 return (searchEngine != null && searchEngine.supportsVoiceSearch());
1106 }
1107
Derek Sollenberger2d4f1e22011-06-01 14:50:42 -04001108 public void showCustomView(Tab tab, View view, int requestedOrientation,
Michael Kolb8233fac2010-10-26 16:08:53 -07001109 WebChromeClient.CustomViewCallback callback) {
1110 if (tab.inForeground()) {
1111 if (mUi.isCustomViewShowing()) {
1112 callback.onCustomViewHidden();
1113 return;
1114 }
Derek Sollenberger2d4f1e22011-06-01 14:50:42 -04001115 mUi.showCustomView(view, requestedOrientation, callback);
Michael Kolb8233fac2010-10-26 16:08:53 -07001116 // Save the menu state and set it to empty while the custom
1117 // view is showing.
1118 mOldMenuState = mMenuState;
1119 mMenuState = EMPTY_MENU;
John Reckd73c5a22010-12-22 10:22:50 -08001120 mActivity.invalidateOptionsMenu();
Michael Kolb8233fac2010-10-26 16:08:53 -07001121 }
1122 }
1123
1124 @Override
1125 public void hideCustomView() {
1126 if (mUi.isCustomViewShowing()) {
1127 mUi.onHideCustomView();
1128 // Reset the old menu state.
1129 mMenuState = mOldMenuState;
1130 mOldMenuState = EMPTY_MENU;
John Reckd73c5a22010-12-22 10:22:50 -08001131 mActivity.invalidateOptionsMenu();
Michael Kolb8233fac2010-10-26 16:08:53 -07001132 }
1133 }
1134
1135 protected void onActivityResult(int requestCode, int resultCode,
1136 Intent intent) {
1137 if (getCurrentTopWebView() == null) return;
1138 switch (requestCode) {
1139 case PREFERENCES_PAGE:
1140 if (resultCode == Activity.RESULT_OK && intent != null) {
1141 String action = intent.getStringExtra(Intent.EXTRA_TEXT);
John Reck35e9dd62011-04-25 09:01:54 -07001142 if (PreferenceKeys.PREF_PRIVACY_CLEAR_HISTORY.equals(action)) {
Michael Kolb8233fac2010-10-26 16:08:53 -07001143 mTabControl.removeParentChildRelationShips();
1144 }
1145 }
1146 break;
1147 case FILE_SELECTED:
Ben Murdoch51f6a2f2011-02-21 12:27:07 +00001148 // Chose a file from the file picker.
John Reck9dfcdb12011-02-22 16:40:46 -08001149 if (null == mUploadHandler) break;
Michael Kolb8233fac2010-10-26 16:08:53 -07001150 mUploadHandler.onResult(resultCode, intent);
Michael Kolb8233fac2010-10-26 16:08:53 -07001151 break;
Ben Murdoch8029a772010-11-16 11:58:21 +00001152 case AUTOFILL_SETUP:
1153 // Determine whether a profile was actually set up or not
1154 // and if so, send the message back to the WebTextView to
1155 // fill the form with the new profile.
1156 if (getSettings().getAutoFillProfile() != null) {
1157 mAutoFillSetupMessage.sendToTarget();
1158 mAutoFillSetupMessage = null;
1159 }
1160 break;
John Reckd3e4d5b2011-07-13 15:48:43 -07001161 case COMBO_VIEW:
1162 if (intent == null || resultCode != Activity.RESULT_OK) {
1163 break;
1164 }
John Reck3ba45532011-08-11 16:26:53 -07001165 mUi.showWeb(false);
John Reckd3e4d5b2011-07-13 15:48:43 -07001166 if (Intent.ACTION_VIEW.equals(intent.getAction())) {
1167 Tab t = getCurrentTab();
1168 Uri uri = intent.getData();
1169 loadUrl(t, uri.toString());
1170 } else if (intent.hasExtra(ComboViewActivity.EXTRA_OPEN_ALL)) {
1171 String[] urls = intent.getStringArrayExtra(
1172 ComboViewActivity.EXTRA_OPEN_ALL);
1173 Tab parent = getCurrentTab();
1174 for (String url : urls) {
1175 parent = openTab(url, parent,
1176 !mSettings.openInBackground(), true);
1177 }
1178 } else if (intent.hasExtra(ComboViewActivity.EXTRA_OPEN_SNAPSHOT)) {
1179 long id = intent.getLongExtra(
1180 ComboViewActivity.EXTRA_OPEN_SNAPSHOT, -1);
1181 if (id >= 0) {
1182 createNewSnapshotTab(id, true);
1183 }
1184 }
1185 break;
Michael Kolb8233fac2010-10-26 16:08:53 -07001186 default:
1187 break;
1188 }
1189 getCurrentTopWebView().requestFocus();
1190 }
1191
1192 /**
1193 * Open the Go page.
1194 * @param startWithHistory If true, open starting on the history tab.
1195 * Otherwise, start with the bookmarks tab.
1196 */
1197 @Override
1198 public void bookmarksOrHistoryPicker(boolean startWithHistory) {
1199 if (mTabControl.getCurrentWebView() == null) {
1200 return;
1201 }
Michael Kolbbd3dd942011-01-12 11:09:38 -08001202 // clear action mode
1203 if (isInCustomActionMode()) {
1204 endActionMode();
1205 }
Michael Kolb8233fac2010-10-26 16:08:53 -07001206 Bundle extras = new Bundle();
1207 // Disable opening in a new window if we have maxed out the windows
1208 extras.putBoolean(BrowserBookmarksPage.EXTRA_DISABLE_WINDOW,
1209 !mTabControl.canCreateNewTab());
John Reck2bc80422011-06-30 15:11:49 -07001210 mUi.showComboView(startWithHistory
1211 ? ComboViews.History : ComboViews.Bookmarks, extras);
Michael Kolb8233fac2010-10-26 16:08:53 -07001212 }
1213
1214 // combo view callbacks
1215
Michael Kolb8233fac2010-10-26 16:08:53 -07001216 // key handling
1217 protected void onBackKey() {
1218 if (!mUi.onBackKey()) {
1219 WebView subwindow = mTabControl.getCurrentSubWindow();
1220 if (subwindow != null) {
1221 if (subwindow.canGoBack()) {
1222 subwindow.goBack();
1223 } else {
1224 dismissSubWindow(mTabControl.getCurrentTab());
1225 }
1226 } else {
1227 goBackOnePageOrQuit();
1228 }
1229 }
1230 }
1231
Michael Kolb4bd767d2011-05-27 11:33:55 -07001232 protected boolean onMenuKey() {
1233 return mUi.onMenuKey();
Michael Kolb2814a362011-05-19 15:49:41 -07001234 }
1235
Michael Kolb8233fac2010-10-26 16:08:53 -07001236 // menu handling and state
1237 // TODO: maybe put into separate handler
1238
1239 protected boolean onCreateOptionsMenu(Menu menu) {
John Reckd73c5a22010-12-22 10:22:50 -08001240 if (mMenuState == EMPTY_MENU) {
1241 return false;
1242 }
Michael Kolb8233fac2010-10-26 16:08:53 -07001243 MenuInflater inflater = mActivity.getMenuInflater();
1244 inflater.inflate(R.menu.browser, menu);
Michael Kolb8233fac2010-10-26 16:08:53 -07001245 return true;
1246 }
1247
1248 protected void onCreateContextMenu(ContextMenu menu, View v,
1249 ContextMenuInfo menuInfo) {
John Reck0f602f32011-07-07 15:38:43 -07001250 if (v instanceof TitleBar) {
Michael Kolb8233fac2010-10-26 16:08:53 -07001251 return;
1252 }
1253 if (!(v instanceof WebView)) {
1254 return;
1255 }
Leon Scroggins026f2542010-11-22 13:26:12 -05001256 final WebView webview = (WebView) v;
Michael Kolb8233fac2010-10-26 16:08:53 -07001257 WebView.HitTestResult result = webview.getHitTestResult();
1258 if (result == null) {
1259 return;
1260 }
1261
1262 int type = result.getType();
1263 if (type == WebView.HitTestResult.UNKNOWN_TYPE) {
1264 Log.w(LOGTAG,
1265 "We should not show context menu when nothing is touched");
1266 return;
1267 }
1268 if (type == WebView.HitTestResult.EDIT_TEXT_TYPE) {
1269 // let TextView handles context menu
1270 return;
1271 }
1272
1273 // Note, http://b/issue?id=1106666 is requesting that
1274 // an inflated menu can be used again. This is not available
1275 // yet, so inflate each time (yuk!)
1276 MenuInflater inflater = mActivity.getMenuInflater();
1277 inflater.inflate(R.menu.browsercontext, menu);
1278
1279 // Show the correct menu group
1280 final String extra = result.getExtra();
1281 menu.setGroupVisible(R.id.PHONE_MENU,
1282 type == WebView.HitTestResult.PHONE_TYPE);
1283 menu.setGroupVisible(R.id.EMAIL_MENU,
1284 type == WebView.HitTestResult.EMAIL_TYPE);
1285 menu.setGroupVisible(R.id.GEO_MENU,
1286 type == WebView.HitTestResult.GEO_TYPE);
1287 menu.setGroupVisible(R.id.IMAGE_MENU,
1288 type == WebView.HitTestResult.IMAGE_TYPE
1289 || type == WebView.HitTestResult.SRC_IMAGE_ANCHOR_TYPE);
1290 menu.setGroupVisible(R.id.ANCHOR_MENU,
1291 type == WebView.HitTestResult.SRC_ANCHOR_TYPE
1292 || type == WebView.HitTestResult.SRC_IMAGE_ANCHOR_TYPE);
Cary Clark8974d282010-11-22 10:46:05 -05001293 boolean hitText = type == WebView.HitTestResult.SRC_ANCHOR_TYPE
1294 || type == WebView.HitTestResult.PHONE_TYPE
1295 || type == WebView.HitTestResult.EMAIL_TYPE
1296 || type == WebView.HitTestResult.GEO_TYPE;
1297 menu.setGroupVisible(R.id.SELECT_TEXT_MENU, hitText);
1298 if (hitText) {
1299 menu.findItem(R.id.select_text_menu_id)
1300 .setOnMenuItemClickListener(new SelectText(webview));
1301 }
Michael Kolb8233fac2010-10-26 16:08:53 -07001302 // Setup custom handling depending on the type
1303 switch (type) {
1304 case WebView.HitTestResult.PHONE_TYPE:
1305 menu.setHeaderTitle(Uri.decode(extra));
1306 menu.findItem(R.id.dial_context_menu_id).setIntent(
1307 new Intent(Intent.ACTION_VIEW, Uri
1308 .parse(WebView.SCHEME_TEL + extra)));
1309 Intent addIntent = new Intent(Intent.ACTION_INSERT_OR_EDIT);
1310 addIntent.putExtra(Insert.PHONE, Uri.decode(extra));
1311 addIntent.setType(ContactsContract.Contacts.CONTENT_ITEM_TYPE);
1312 menu.findItem(R.id.add_contact_context_menu_id).setIntent(
1313 addIntent);
1314 menu.findItem(R.id.copy_phone_context_menu_id)
1315 .setOnMenuItemClickListener(
1316 new Copy(extra));
1317 break;
1318
1319 case WebView.HitTestResult.EMAIL_TYPE:
1320 menu.setHeaderTitle(extra);
1321 menu.findItem(R.id.email_context_menu_id).setIntent(
1322 new Intent(Intent.ACTION_VIEW, Uri
1323 .parse(WebView.SCHEME_MAILTO + extra)));
1324 menu.findItem(R.id.copy_mail_context_menu_id)
1325 .setOnMenuItemClickListener(
1326 new Copy(extra));
1327 break;
1328
1329 case WebView.HitTestResult.GEO_TYPE:
1330 menu.setHeaderTitle(extra);
1331 menu.findItem(R.id.map_context_menu_id).setIntent(
1332 new Intent(Intent.ACTION_VIEW, Uri
1333 .parse(WebView.SCHEME_GEO
1334 + URLEncoder.encode(extra))));
1335 menu.findItem(R.id.copy_geo_context_menu_id)
1336 .setOnMenuItemClickListener(
1337 new Copy(extra));
1338 break;
1339
1340 case WebView.HitTestResult.SRC_ANCHOR_TYPE:
1341 case WebView.HitTestResult.SRC_IMAGE_ANCHOR_TYPE:
Michael Kolb4c537ce2011-01-13 15:19:33 -08001342 menu.setHeaderTitle(extra);
Michael Kolb8233fac2010-10-26 16:08:53 -07001343 // decide whether to show the open link in new tab option
1344 boolean showNewTab = mTabControl.canCreateNewTab();
1345 MenuItem newTabItem
1346 = menu.findItem(R.id.open_newtab_context_menu_id);
John Reck35e9dd62011-04-25 09:01:54 -07001347 newTabItem.setTitle(getSettings().openInBackground()
Michael Kolb2dd65c82011-01-14 11:07:38 -08001348 ? R.string.contextmenu_openlink_newwindow_background
1349 : R.string.contextmenu_openlink_newwindow);
Michael Kolb8233fac2010-10-26 16:08:53 -07001350 newTabItem.setVisible(showNewTab);
1351 if (showNewTab) {
Leon Scroggins026f2542010-11-22 13:26:12 -05001352 if (WebView.HitTestResult.SRC_IMAGE_ANCHOR_TYPE == type) {
1353 newTabItem.setOnMenuItemClickListener(
1354 new MenuItem.OnMenuItemClickListener() {
1355 @Override
1356 public boolean onMenuItemClick(MenuItem item) {
1357 final HashMap<String, WebView> hrefMap =
1358 new HashMap<String, WebView>();
1359 hrefMap.put("webview", webview);
1360 final Message msg = mHandler.obtainMessage(
1361 FOCUS_NODE_HREF,
1362 R.id.open_newtab_context_menu_id,
1363 0, hrefMap);
1364 webview.requestFocusNodeHref(msg);
1365 return true;
Michael Kolb8233fac2010-10-26 16:08:53 -07001366 }
Leon Scroggins026f2542010-11-22 13:26:12 -05001367 });
1368 } else {
1369 newTabItem.setOnMenuItemClickListener(
1370 new MenuItem.OnMenuItemClickListener() {
1371 @Override
1372 public boolean onMenuItemClick(MenuItem item) {
1373 final Tab parent = mTabControl.getCurrentTab();
John Reck5949c662011-05-27 09:52:29 -07001374 openTab(extra, parent,
1375 !mSettings.openInBackground(),
1376 true);
Leon Scroggins026f2542010-11-22 13:26:12 -05001377 return true;
1378 }
1379 });
1380 }
Michael Kolb8233fac2010-10-26 16:08:53 -07001381 }
Michael Kolb8233fac2010-10-26 16:08:53 -07001382 if (type == WebView.HitTestResult.SRC_ANCHOR_TYPE) {
1383 break;
1384 }
1385 // otherwise fall through to handle image part
1386 case WebView.HitTestResult.IMAGE_TYPE:
1387 if (type == WebView.HitTestResult.IMAGE_TYPE) {
1388 menu.setHeaderTitle(extra);
1389 }
1390 menu.findItem(R.id.view_image_context_menu_id).setIntent(
1391 new Intent(Intent.ACTION_VIEW, Uri.parse(extra)));
1392 menu.findItem(R.id.download_context_menu_id).
Kristian Monsenbc5cc752011-03-02 13:14:03 +00001393 setOnMenuItemClickListener(
1394 new Download(mActivity, extra, webview.isPrivateBrowsingEnabled()));
John Reck3527dd12011-02-22 10:35:29 -08001395 menu.findItem(R.id.set_wallpaper_context_menu_id).
1396 setOnMenuItemClickListener(new WallpaperHandler(mActivity,
1397 extra));
Michael Kolb8233fac2010-10-26 16:08:53 -07001398 break;
1399
1400 default:
1401 Log.w(LOGTAG, "We should not get here.");
1402 break;
1403 }
1404 //update the ui
1405 mUi.onContextMenuCreated(menu);
1406 }
1407
1408 /**
1409 * As the menu can be open when loading state changes
1410 * we must manually update the state of the stop/reload menu
1411 * item
1412 */
1413 private void updateInLoadMenuItems(Menu menu) {
1414 if (menu == null) {
1415 return;
1416 }
1417 MenuItem dest = menu.findItem(R.id.stop_reload_menu_id);
1418 MenuItem src = mInLoad ?
1419 menu.findItem(R.id.stop_menu_id):
1420 menu.findItem(R.id.reload_menu_id);
1421 if (src != null) {
1422 dest.setIcon(src.getIcon());
1423 dest.setTitle(src.getTitle());
1424 }
1425 }
1426
John Reckb3417f02011-01-14 11:01:05 -08001427 boolean onPrepareOptionsMenu(Menu menu) {
John Recke1a03a32011-09-14 17:04:16 -07001428 updateInLoadMenuItems(menu);
1429 // hold on to the menu reference here; it is used by the page callbacks
1430 // to update the menu based on loading state
1431 mCachedMenu = menu;
Michael Kolb8233fac2010-10-26 16:08:53 -07001432 // Note: setVisible will decide whether an item is visible; while
1433 // setEnabled() will decide whether an item is enabled, which also means
1434 // whether the matching shortcut key will function.
1435 switch (mMenuState) {
1436 case EMPTY_MENU:
1437 if (mCurrentMenuState != mMenuState) {
1438 menu.setGroupVisible(R.id.MAIN_MENU, false);
1439 menu.setGroupEnabled(R.id.MAIN_MENU, false);
1440 menu.setGroupEnabled(R.id.MAIN_SHORTCUT_MENU, false);
1441 }
1442 break;
1443 default:
1444 if (mCurrentMenuState != mMenuState) {
1445 menu.setGroupVisible(R.id.MAIN_MENU, true);
1446 menu.setGroupEnabled(R.id.MAIN_MENU, true);
1447 menu.setGroupEnabled(R.id.MAIN_SHORTCUT_MENU, true);
1448 }
Michael Kolb4bf79712011-07-14 14:18:12 -07001449 updateMenuState(getCurrentTab(), menu);
Michael Kolb8233fac2010-10-26 16:08:53 -07001450 break;
1451 }
1452 mCurrentMenuState = mMenuState;
Michael Kolb1acef692011-03-08 14:12:06 -08001453 return mUi.onPrepareOptionsMenu(menu);
Michael Kolb8233fac2010-10-26 16:08:53 -07001454 }
1455
Michael Kolb4bf79712011-07-14 14:18:12 -07001456 @Override
1457 public void updateMenuState(Tab tab, Menu menu) {
1458 boolean canGoBack = false;
1459 boolean canGoForward = false;
1460 boolean isHome = false;
John Reck42229bc2011-08-19 13:26:43 -07001461 boolean isDesktopUa = false;
John Recke1a03a32011-09-14 17:04:16 -07001462 boolean isLive = false;
Michael Kolb4bf79712011-07-14 14:18:12 -07001463 if (tab != null) {
1464 canGoBack = tab.canGoBack();
1465 canGoForward = tab.canGoForward();
1466 isHome = mSettings.getHomePage().equals(tab.getUrl());
John Reck42229bc2011-08-19 13:26:43 -07001467 isDesktopUa = mSettings.hasDesktopUseragent(tab.getWebView());
John Recke1a03a32011-09-14 17:04:16 -07001468 isLive = !tab.isSnapshot();
Michael Kolb4bf79712011-07-14 14:18:12 -07001469 }
1470 final MenuItem back = menu.findItem(R.id.back_menu_id);
1471 back.setEnabled(canGoBack);
1472
1473 final MenuItem home = menu.findItem(R.id.homepage_menu_id);
1474 home.setEnabled(!isHome);
1475
1476 final MenuItem forward = menu.findItem(R.id.forward_menu_id);
1477 forward.setEnabled(canGoForward);
1478
1479 final MenuItem source = menu.findItem(mInLoad ? R.id.stop_menu_id : R.id.reload_menu_id);
1480 final MenuItem dest = menu.findItem(R.id.stop_reload_menu_id);
Michael Kolb7ab75ee2011-07-14 16:36:38 -07001481 if (source != null && dest != null) {
1482 dest.setTitle(source.getTitle());
1483 dest.setIcon(source.getIcon());
1484 }
John Recke1a03a32011-09-14 17:04:16 -07001485 menu.setGroupVisible(R.id.NAV_MENU, isLive);
Michael Kolb4bf79712011-07-14 14:18:12 -07001486
1487 // decide whether to show the share link option
1488 PackageManager pm = mActivity.getPackageManager();
1489 Intent send = new Intent(Intent.ACTION_SEND);
1490 send.setType("text/plain");
1491 ResolveInfo ri = pm.resolveActivity(send,
1492 PackageManager.MATCH_DEFAULT_ONLY);
1493 menu.findItem(R.id.share_page_menu_id).setVisible(ri != null);
1494
1495 boolean isNavDump = mSettings.enableNavDump();
1496 final MenuItem nav = menu.findItem(R.id.dump_nav_menu_id);
1497 nav.setVisible(isNavDump);
1498 nav.setEnabled(isNavDump);
1499
1500 boolean showDebugSettings = mSettings.isDebugEnabled();
1501 final MenuItem counter = menu.findItem(R.id.dump_counters_menu_id);
1502 counter.setVisible(showDebugSettings);
1503 counter.setEnabled(showDebugSettings);
John Reck42229bc2011-08-19 13:26:43 -07001504 final MenuItem uaSwitcher = menu.findItem(R.id.ua_desktop_menu_id);
1505 uaSwitcher.setChecked(isDesktopUa);
John Recke1a03a32011-09-14 17:04:16 -07001506 menu.setGroupVisible(R.id.LIVE_MENU, isLive);
1507 menu.setGroupVisible(R.id.SNAPSHOT_MENU, !isLive);
Michael Kolb4bf79712011-07-14 14:18:12 -07001508
Michael Kolb7bdee0b2011-08-01 11:55:38 -07001509 mUi.updateMenuState(tab, menu);
Michael Kolb4bf79712011-07-14 14:18:12 -07001510 }
1511
Michael Kolb8233fac2010-10-26 16:08:53 -07001512 public boolean onOptionsItemSelected(MenuItem item) {
Michael Kolb8233fac2010-10-26 16:08:53 -07001513 if (null == getCurrentTopWebView()) {
1514 return false;
1515 }
1516 if (mMenuIsDown) {
1517 // The shortcut action consumes the MENU. Even if it is still down,
1518 // it won't trigger the next shortcut action. In the case of the
1519 // shortcut action triggering a new activity, like Bookmarks, we
1520 // won't get onKeyUp for MENU. So it is important to reset it here.
1521 mMenuIsDown = false;
1522 }
Michael Kolb3ca12752011-07-20 13:52:25 -07001523 if (mUi.onOptionsItemSelected(item)) {
1524 // ui callback handled it
1525 return true;
1526 }
Michael Kolb8233fac2010-10-26 16:08:53 -07001527 switch (item.getItemId()) {
1528 // -- Main menu
1529 case R.id.new_tab_menu_id:
1530 openTabToHomePage();
1531 break;
1532
1533 case R.id.incognito_menu_id:
Michael Kolb519d2282011-05-09 17:03:19 -07001534 openIncognitoTab();
Michael Kolb8233fac2010-10-26 16:08:53 -07001535 break;
1536
1537 case R.id.goto_menu_id:
1538 editUrl();
1539 break;
1540
1541 case R.id.bookmarks_menu_id:
1542 bookmarksOrHistoryPicker(false);
1543 break;
1544
Michael Kolb8233fac2010-10-26 16:08:53 -07001545 case R.id.add_bookmark_menu_id:
John Recka60fffa2011-09-06 16:30:29 -07001546 Intent bookmarkIntent = createBookmarkCurrentPageIntent(false);
1547 if (bookmarkIntent != null) {
1548 mActivity.startActivity(bookmarkIntent);
1549 }
Michael Kolb8233fac2010-10-26 16:08:53 -07001550 break;
1551
1552 case R.id.stop_reload_menu_id:
1553 if (mInLoad) {
1554 stopLoading();
1555 } else {
1556 getCurrentTopWebView().reload();
1557 }
1558 break;
1559
1560 case R.id.back_menu_id:
John Reckef654f12011-07-12 16:42:08 -07001561 getCurrentTab().goBack();
Michael Kolb8233fac2010-10-26 16:08:53 -07001562 break;
1563
1564 case R.id.forward_menu_id:
John Reckef654f12011-07-12 16:42:08 -07001565 getCurrentTab().goForward();
Michael Kolb8233fac2010-10-26 16:08:53 -07001566 break;
1567
1568 case R.id.close_menu_id:
1569 // Close the subwindow if it exists.
1570 if (mTabControl.getCurrentSubWindow() != null) {
1571 dismissSubWindow(mTabControl.getCurrentTab());
1572 break;
1573 }
1574 closeCurrentTab();
1575 break;
1576
1577 case R.id.homepage_menu_id:
1578 Tab current = mTabControl.getCurrentTab();
John Reck26b18322011-06-21 13:08:58 -07001579 loadUrl(current, mSettings.getHomePage());
Michael Kolb8233fac2010-10-26 16:08:53 -07001580 break;
1581
1582 case R.id.preferences_menu_id:
1583 Intent intent = new Intent(mActivity, BrowserPreferencesPage.class);
1584 intent.putExtra(BrowserPreferencesPage.CURRENT_PAGE,
1585 getCurrentTopWebView().getUrl());
1586 mActivity.startActivityForResult(intent, PREFERENCES_PAGE);
1587 break;
1588
1589 case R.id.find_menu_id:
Leon Scroggins1c00d5e2011-01-04 10:45:58 -05001590 getCurrentTopWebView().showFindDialog(null, true);
Michael Kolb8233fac2010-10-26 16:08:53 -07001591 break;
1592
John Reck2bc80422011-06-30 15:11:49 -07001593 case R.id.save_snapshot_menu_id:
1594 final Tab source = getTabControl().getCurrentTab();
John Reckf33b1632011-06-04 20:00:23 -07001595 if (source == null) break;
John Reckd8c74522011-06-14 08:45:00 -07001596 final ContentResolver cr = mActivity.getContentResolver();
1597 final ContentValues values = source.createSnapshotValues();
John Reck2bc80422011-06-30 15:11:49 -07001598 if (values != null) {
1599 new AsyncTask<Tab, Void, Long>() {
John Reckd8c74522011-06-14 08:45:00 -07001600
John Reck2bc80422011-06-30 15:11:49 -07001601 @Override
1602 protected Long doInBackground(Tab... params) {
1603 Uri result = cr.insert(Snapshots.CONTENT_URI, values);
1604 long id = ContentUris.parseId(result);
1605 return id;
John Reckd8c74522011-06-14 08:45:00 -07001606 }
John Reckf33b1632011-06-04 20:00:23 -07001607
John Reck2bc80422011-06-30 15:11:49 -07001608 @Override
1609 protected void onPostExecute(Long id) {
1610 Bundle b = new Bundle();
1611 b.putLong(BrowserSnapshotPage.EXTRA_ANIMATE_ID, id);
1612 mUi.showComboView(ComboViews.Snapshots, b);
1613 };
1614 }.execute(source);
1615 } else {
1616 Toast.makeText(mActivity, R.string.snapshot_failed,
Leon Scrogginsac993842011-02-02 12:54:07 -05001617 Toast.LENGTH_SHORT).show();
Leon Scrogginsac993842011-02-02 12:54:07 -05001618 }
Leon Scrogginsac993842011-02-02 12:54:07 -05001619 break;
1620
Michael Kolb8233fac2010-10-26 16:08:53 -07001621 case R.id.page_info_menu_id:
Huahui Wuae0c0412011-06-28 10:17:05 -07001622 mPageDialogsHandler.showPageInfo(mTabControl.getCurrentTab(), false, null);
Michael Kolb8233fac2010-10-26 16:08:53 -07001623 break;
1624
John Recke1a03a32011-09-14 17:04:16 -07001625 case R.id.snapshot_go_live:
1626 goLive();
1627 return true;
1628
Michael Kolb8233fac2010-10-26 16:08:53 -07001629 case R.id.classic_history_menu_id:
1630 bookmarksOrHistoryPicker(true);
1631 break;
1632
Michael Kolb8233fac2010-10-26 16:08:53 -07001633 case R.id.share_page_menu_id:
1634 Tab currentTab = mTabControl.getCurrentTab();
1635 if (null == currentTab) {
Michael Kolb8233fac2010-10-26 16:08:53 -07001636 return false;
1637 }
Michael Kolbba99c5d2010-11-29 14:57:41 -08001638 shareCurrentPage(currentTab);
Michael Kolb8233fac2010-10-26 16:08:53 -07001639 break;
1640
1641 case R.id.dump_nav_menu_id:
1642 getCurrentTopWebView().debugDump();
1643 break;
1644
1645 case R.id.dump_counters_menu_id:
1646 getCurrentTopWebView().dumpV8Counters();
1647 break;
1648
1649 case R.id.zoom_in_menu_id:
1650 getCurrentTopWebView().zoomIn();
1651 break;
1652
1653 case R.id.zoom_out_menu_id:
1654 getCurrentTopWebView().zoomOut();
1655 break;
1656
1657 case R.id.view_downloads_menu_id:
1658 viewDownloads();
1659 break;
1660
John Reck42229bc2011-08-19 13:26:43 -07001661 case R.id.ua_desktop_menu_id:
1662 WebView web = getCurrentWebView();
1663 mSettings.toggleDesktopUseragent(web);
1664 web.loadUrl(web.getOriginalUrl());
1665 break;
1666
Michael Kolb8233fac2010-10-26 16:08:53 -07001667 case R.id.window_one_menu_id:
1668 case R.id.window_two_menu_id:
1669 case R.id.window_three_menu_id:
1670 case R.id.window_four_menu_id:
1671 case R.id.window_five_menu_id:
1672 case R.id.window_six_menu_id:
1673 case R.id.window_seven_menu_id:
1674 case R.id.window_eight_menu_id:
1675 {
1676 int menuid = item.getItemId();
1677 for (int id = 0; id < WINDOW_SHORTCUT_ID_ARRAY.length; id++) {
1678 if (WINDOW_SHORTCUT_ID_ARRAY[id] == menuid) {
1679 Tab desiredTab = mTabControl.getTab(id);
1680 if (desiredTab != null &&
1681 desiredTab != mTabControl.getCurrentTab()) {
Michael Kolbc831b632011-05-11 09:30:34 -07001682 switchToTab(desiredTab);
Michael Kolb8233fac2010-10-26 16:08:53 -07001683 }
1684 break;
1685 }
1686 }
1687 }
1688 break;
1689
1690 default:
1691 return false;
1692 }
Michael Kolb8233fac2010-10-26 16:08:53 -07001693 return true;
1694 }
1695
John Recke1a03a32011-09-14 17:04:16 -07001696 private void goLive() {
1697 Tab t = getCurrentTab();
1698 t.loadUrl(t.getUrl(), null);
1699 }
1700
Michael Kolb8233fac2010-10-26 16:08:53 -07001701 public boolean onContextItemSelected(MenuItem item) {
John Reckdbf57df2010-11-09 16:34:03 -08001702 // Let the History and Bookmark fragments handle menus they created.
1703 if (item.getGroupId() == R.id.CONTEXT_MENU) {
1704 return false;
1705 }
1706
Michael Kolb8233fac2010-10-26 16:08:53 -07001707 int id = item.getItemId();
1708 boolean result = true;
1709 switch (id) {
Michael Kolb8233fac2010-10-26 16:08:53 -07001710 // -- Browser context menu
1711 case R.id.open_context_menu_id:
Michael Kolb8233fac2010-10-26 16:08:53 -07001712 case R.id.save_link_context_menu_id:
Michael Kolb8233fac2010-10-26 16:08:53 -07001713 case R.id.copy_link_context_menu_id:
1714 final WebView webView = getCurrentTopWebView();
1715 if (null == webView) {
1716 result = false;
1717 break;
1718 }
1719 final HashMap<String, WebView> hrefMap =
1720 new HashMap<String, WebView>();
1721 hrefMap.put("webview", webView);
1722 final Message msg = mHandler.obtainMessage(
1723 FOCUS_NODE_HREF, id, 0, hrefMap);
1724 webView.requestFocusNodeHref(msg);
1725 break;
1726
1727 default:
1728 // For other context menus
1729 result = onOptionsItemSelected(item);
1730 }
Michael Kolb8233fac2010-10-26 16:08:53 -07001731 return result;
1732 }
1733
1734 /**
1735 * support programmatically opening the context menu
1736 */
1737 public void openContextMenu(View view) {
1738 mActivity.openContextMenu(view);
1739 }
1740
1741 /**
1742 * programmatically open the options menu
1743 */
1744 public void openOptionsMenu() {
1745 mActivity.openOptionsMenu();
1746 }
1747
1748 public boolean onMenuOpened(int featureId, Menu menu) {
1749 if (mOptionsMenuOpen) {
1750 if (mConfigChanged) {
1751 // We do not need to make any changes to the state of the
1752 // title bar, since the only thing that happened was a
1753 // change in orientation
1754 mConfigChanged = false;
1755 } else {
1756 if (!mExtendedMenuOpen) {
1757 mExtendedMenuOpen = true;
1758 mUi.onExtendedMenuOpened();
1759 } else {
1760 // Switching the menu back to icon view, so show the
1761 // title bar once again.
1762 mExtendedMenuOpen = false;
1763 mUi.onExtendedMenuClosed(mInLoad);
Michael Kolb8233fac2010-10-26 16:08:53 -07001764 }
1765 }
1766 } else {
1767 // The options menu is closed, so open it, and show the title
1768 mOptionsMenuOpen = true;
1769 mConfigChanged = false;
1770 mExtendedMenuOpen = false;
1771 mUi.onOptionsMenuOpened();
1772 }
1773 return true;
1774 }
1775
1776 public void onOptionsMenuClosed(Menu menu) {
1777 mOptionsMenuOpen = false;
1778 mUi.onOptionsMenuClosed(mInLoad);
1779 }
1780
1781 public void onContextMenuClosed(Menu menu) {
1782 mUi.onContextMenuClosed(menu, mInLoad);
1783 }
1784
1785 // Helper method for getting the top window.
1786 @Override
1787 public WebView getCurrentTopWebView() {
1788 return mTabControl.getCurrentTopWebView();
1789 }
1790
1791 @Override
1792 public WebView getCurrentWebView() {
1793 return mTabControl.getCurrentWebView();
1794 }
1795
1796 /*
1797 * This method is called as a result of the user selecting the options
1798 * menu to see the download window. It shows the download window on top of
1799 * the current window.
1800 */
1801 void viewDownloads() {
1802 Intent intent = new Intent(DownloadManager.ACTION_VIEW_DOWNLOADS);
1803 mActivity.startActivity(intent);
1804 }
1805
John Reck30b065e2011-07-19 10:58:05 -07001806 int getActionModeHeight() {
1807 TypedArray actionBarSizeTypedArray = mActivity.obtainStyledAttributes(
1808 new int[] { android.R.attr.actionBarSize });
1809 int size = (int) actionBarSizeTypedArray.getDimension(0, 0f);
1810 actionBarSizeTypedArray.recycle();
1811 return size;
1812 }
1813
Michael Kolb8233fac2010-10-26 16:08:53 -07001814 // action mode
1815
1816 void onActionModeStarted(ActionMode mode) {
1817 mUi.onActionModeStarted(mode);
1818 mActionMode = mode;
1819 }
1820
1821 /*
1822 * True if a custom ActionMode (i.e. find or select) is in use.
1823 */
1824 @Override
1825 public boolean isInCustomActionMode() {
1826 return mActionMode != null;
1827 }
1828
1829 /*
1830 * End the current ActionMode.
1831 */
1832 @Override
1833 public void endActionMode() {
1834 if (mActionMode != null) {
1835 mActionMode.finish();
1836 }
1837 }
1838
1839 /*
1840 * Called by find and select when they are finished. Replace title bars
1841 * as necessary.
1842 */
1843 public void onActionModeFinished(ActionMode mode) {
1844 if (!isInCustomActionMode()) return;
1845 mUi.onActionModeFinished(mInLoad);
1846 mActionMode = null;
1847 }
1848
1849 boolean isInLoad() {
1850 return mInLoad;
1851 }
1852
1853 // bookmark handling
1854
1855 /**
1856 * add the current page as a bookmark to the given folder id
1857 * @param folderId use -1 for the default folder
John Reckd3e4d5b2011-07-13 15:48:43 -07001858 * @param editExisting If true, check to see whether the site is already
Leon Scrogginsbdff8a72011-02-11 15:49:04 -05001859 * bookmarked, and if it is, edit that bookmark. If false, and
1860 * the site is already bookmarked, do not attempt to edit the
1861 * existing bookmark.
Michael Kolb8233fac2010-10-26 16:08:53 -07001862 */
1863 @Override
John Reckd3e4d5b2011-07-13 15:48:43 -07001864 public Intent createBookmarkCurrentPageIntent(boolean editExisting) {
John Recka60fffa2011-09-06 16:30:29 -07001865 WebView w = getCurrentTopWebView();
1866 if (w == null) {
1867 return null;
1868 }
Michael Kolb8233fac2010-10-26 16:08:53 -07001869 Intent i = new Intent(mActivity,
1870 AddBookmarkPage.class);
Michael Kolb8233fac2010-10-26 16:08:53 -07001871 i.putExtra(BrowserContract.Bookmarks.URL, w.getUrl());
1872 i.putExtra(BrowserContract.Bookmarks.TITLE, w.getTitle());
1873 String touchIconUrl = w.getTouchIconUrl();
1874 if (touchIconUrl != null) {
1875 i.putExtra(AddBookmarkPage.TOUCH_ICON_URL, touchIconUrl);
1876 WebSettings settings = w.getSettings();
1877 if (settings != null) {
1878 i.putExtra(AddBookmarkPage.USER_AGENT,
1879 settings.getUserAgentString());
1880 }
1881 }
1882 i.putExtra(BrowserContract.Bookmarks.THUMBNAIL,
1883 createScreenshot(w, getDesiredThumbnailWidth(mActivity),
1884 getDesiredThumbnailHeight(mActivity)));
1885 i.putExtra(BrowserContract.Bookmarks.FAVICON, w.getFavicon());
John Reckd3e4d5b2011-07-13 15:48:43 -07001886 if (editExisting) {
Leon Scrogginsbdff8a72011-02-11 15:49:04 -05001887 i.putExtra(AddBookmarkPage.CHECK_FOR_DUPE, true);
1888 }
Michael Kolb8233fac2010-10-26 16:08:53 -07001889 // Put the dialog at the upper right of the screen, covering the
1890 // star on the title bar.
1891 i.putExtra("gravity", Gravity.RIGHT | Gravity.TOP);
John Reckd3e4d5b2011-07-13 15:48:43 -07001892 return i;
Michael Kolb8233fac2010-10-26 16:08:53 -07001893 }
1894
1895 // file chooser
1896 public void openFileChooser(ValueCallback<Uri> uploadMsg, String acceptType) {
1897 mUploadHandler = new UploadHandler(this);
1898 mUploadHandler.openFileChooser(uploadMsg, acceptType);
1899 }
1900
1901 // thumbnails
1902
1903 /**
1904 * Return the desired width for thumbnail screenshots, which are stored in
1905 * the database, and used on the bookmarks screen.
1906 * @param context Context for finding out the density of the screen.
1907 * @return desired width for thumbnail screenshot.
1908 */
1909 static int getDesiredThumbnailWidth(Context context) {
1910 return context.getResources().getDimensionPixelOffset(
1911 R.dimen.bookmarkThumbnailWidth);
1912 }
1913
1914 /**
1915 * Return the desired height for thumbnail screenshots, which are stored in
1916 * the database, and used on the bookmarks screen.
1917 * @param context Context for finding out the density of the screen.
1918 * @return desired height for thumbnail screenshot.
1919 */
1920 static int getDesiredThumbnailHeight(Context context) {
1921 return context.getResources().getDimensionPixelOffset(
1922 R.dimen.bookmarkThumbnailHeight);
1923 }
1924
John Reck8cc92352011-07-06 17:41:52 -07001925 static Bitmap createScreenshot(WebView view, int width, int height) {
John Reckd7dd9b22011-08-30 09:18:29 -07001926 if (view == null || view.getContentHeight() == 0
1927 || view.getContentWidth() == 0) {
1928 return null;
1929 }
John Reck5c6ac2f2011-01-05 10:18:03 -08001930 // We render to a bitmap 2x the desired size so that we can then
1931 // re-scale it with filtering since canvas.scale doesn't filter
1932 // This helps reduce aliasing at the cost of being slightly blurry
1933 final int filter_scale = 2;
John Reckd7dd9b22011-08-30 09:18:29 -07001934 int scaledWidth = width * filter_scale;
1935 int scaledHeight = height * filter_scale;
1936 if (sThumbnailBitmap == null || sThumbnailBitmap.getWidth() != scaledWidth
1937 || sThumbnailBitmap.getHeight() != scaledHeight) {
1938 if (sThumbnailBitmap != null) {
1939 sThumbnailBitmap.recycle();
1940 sThumbnailBitmap = null;
1941 }
1942 sThumbnailBitmap =
1943 Bitmap.createBitmap(scaledWidth, scaledHeight, Bitmap.Config.RGB_565);
Michael Kolb8233fac2010-10-26 16:08:53 -07001944 }
John Reckd7dd9b22011-08-30 09:18:29 -07001945 Canvas canvas = new Canvas(sThumbnailBitmap);
1946 int contentWidth = view.getContentWidth();
1947 float overviewScale = scaledWidth / (view.getScale() * contentWidth);
1948 if (view instanceof BrowserWebView) {
1949 int dy = -((BrowserWebView)view).getTitleHeight();
1950 canvas.translate(0, dy * overviewScale);
1951 }
1952
1953 canvas.scale(overviewScale, overviewScale);
1954
1955 if (view instanceof BrowserWebView) {
1956 ((BrowserWebView)view).drawContent(canvas);
Michael Kolb8233fac2010-10-26 16:08:53 -07001957 } else {
John Reckd7dd9b22011-08-30 09:18:29 -07001958 view.draw(canvas);
Michael Kolb8233fac2010-10-26 16:08:53 -07001959 }
John Reckd7dd9b22011-08-30 09:18:29 -07001960 Bitmap ret = Bitmap.createScaledBitmap(sThumbnailBitmap,
1961 width, height, true);
Dianne Hackborn43cfe8a2011-08-02 16:59:35 -07001962 canvas.setBitmap(null);
John Reck5c6ac2f2011-01-05 10:18:03 -08001963 return ret;
Michael Kolb8233fac2010-10-26 16:08:53 -07001964 }
1965
John Reck34ef2672011-02-10 11:30:55 -08001966 private void updateScreenshot(Tab tab) {
Michael Kolb8233fac2010-10-26 16:08:53 -07001967 // If this is a bookmarked site, add a screenshot to the database.
Michael Kolb8233fac2010-10-26 16:08:53 -07001968 // FIXME: Would like to make sure there is actually something to
1969 // draw, but the API for that (WebViewCore.pictureReady()) is not
1970 // currently accessible here.
1971
John Reck34ef2672011-02-10 11:30:55 -08001972 WebView view = tab.getWebView();
John Reck7a591202011-02-16 15:44:01 -08001973 if (view == null) {
1974 // Tab was destroyed
1975 return;
1976 }
John Reck34ef2672011-02-10 11:30:55 -08001977 final String url = tab.getUrl();
1978 final String originalUrl = view.getOriginalUrl();
1979
1980 if (TextUtils.isEmpty(url)) {
1981 return;
1982 }
1983
1984 // Only update thumbnails for web urls (http(s)://), not for
1985 // about:, javascript:, data:, etc...
1986 // Unless it is a bookmarked site, then always update
1987 if (!Patterns.WEB_URL.matcher(url).matches() && !tab.isBookmarkedSite()) {
1988 return;
1989 }
1990
Michael Kolb8233fac2010-10-26 16:08:53 -07001991 final Bitmap bm = createScreenshot(view, getDesiredThumbnailWidth(mActivity),
1992 getDesiredThumbnailHeight(mActivity));
1993 if (bm == null) {
1994 return;
1995 }
1996
1997 final ContentResolver cr = mActivity.getContentResolver();
John Reck34ef2672011-02-10 11:30:55 -08001998 new AsyncTask<Void, Void, Void>() {
1999 @Override
2000 protected Void doInBackground(Void... unused) {
2001 Cursor cursor = null;
2002 try {
2003 // TODO: Clean this up
2004 cursor = Bookmarks.queryCombinedForUrl(cr, originalUrl, url);
2005 if (cursor != null && cursor.moveToFirst()) {
2006 final ByteArrayOutputStream os =
2007 new ByteArrayOutputStream();
2008 bm.compress(Bitmap.CompressFormat.PNG, 100, os);
Michael Kolb8233fac2010-10-26 16:08:53 -07002009
John Reck34ef2672011-02-10 11:30:55 -08002010 ContentValues values = new ContentValues();
2011 values.put(Images.THUMBNAIL, os.toByteArray());
Michael Kolb8233fac2010-10-26 16:08:53 -07002012
John Reck34ef2672011-02-10 11:30:55 -08002013 do {
John Reck617fd832011-02-16 14:35:59 -08002014 values.put(Images.URL, cursor.getString(0));
John Reck34ef2672011-02-10 11:30:55 -08002015 cr.update(Images.CONTENT_URI, values, null, null);
2016 } while (cursor.moveToNext());
Michael Kolb8233fac2010-10-26 16:08:53 -07002017 }
John Reck34ef2672011-02-10 11:30:55 -08002018 } catch (IllegalStateException e) {
2019 // Ignore
2020 } finally {
2021 if (cursor != null) cursor.close();
Michael Kolb8233fac2010-10-26 16:08:53 -07002022 }
John Reck34ef2672011-02-10 11:30:55 -08002023 return null;
2024 }
2025 }.execute();
Michael Kolb8233fac2010-10-26 16:08:53 -07002026 }
2027
2028 private class Copy implements OnMenuItemClickListener {
2029 private CharSequence mText;
2030
2031 public boolean onMenuItemClick(MenuItem item) {
2032 copy(mText);
2033 return true;
2034 }
2035
2036 public Copy(CharSequence toCopy) {
2037 mText = toCopy;
2038 }
2039 }
2040
Leon Scroggins63c02662010-11-18 15:16:27 -05002041 private static class Download implements OnMenuItemClickListener {
2042 private Activity mActivity;
Michael Kolb8233fac2010-10-26 16:08:53 -07002043 private String mText;
Kristian Monsenbc5cc752011-03-02 13:14:03 +00002044 private boolean mPrivateBrowsing;
Michael Kolb8233fac2010-10-26 16:08:53 -07002045
2046 public boolean onMenuItemClick(MenuItem item) {
Leon Scroggins63c02662010-11-18 15:16:27 -05002047 DownloadHandler.onDownloadStartNoStream(mActivity, mText, null,
Kristian Monsenbc5cc752011-03-02 13:14:03 +00002048 null, null, mPrivateBrowsing);
Michael Kolb8233fac2010-10-26 16:08:53 -07002049 return true;
2050 }
2051
Kristian Monsenbc5cc752011-03-02 13:14:03 +00002052 public Download(Activity activity, String toDownload, boolean privateBrowsing) {
Leon Scroggins63c02662010-11-18 15:16:27 -05002053 mActivity = activity;
Michael Kolb8233fac2010-10-26 16:08:53 -07002054 mText = toDownload;
Kristian Monsenbc5cc752011-03-02 13:14:03 +00002055 mPrivateBrowsing = privateBrowsing;
Michael Kolb8233fac2010-10-26 16:08:53 -07002056 }
2057 }
2058
Cary Clark8974d282010-11-22 10:46:05 -05002059 private static class SelectText implements OnMenuItemClickListener {
2060 private WebView mWebView;
2061
2062 public boolean onMenuItemClick(MenuItem item) {
2063 if (mWebView != null) {
2064 return mWebView.selectText();
2065 }
2066 return false;
2067 }
2068
2069 public SelectText(WebView webView) {
2070 mWebView = webView;
2071 }
2072
2073 }
2074
Michael Kolb8233fac2010-10-26 16:08:53 -07002075 /********************** TODO: UI stuff *****************************/
2076
2077 // these methods have been copied, they still need to be cleaned up
2078
2079 /****************** tabs ***************************************************/
2080
2081 // basic tab interactions:
2082
2083 // it is assumed that tabcontrol already knows about the tab
2084 protected void addTab(Tab tab) {
2085 mUi.addTab(tab);
2086 }
2087
2088 protected void removeTab(Tab tab) {
2089 mUi.removeTab(tab);
2090 mTabControl.removeTab(tab);
John Reck378a4102011-06-09 16:23:01 -07002091 mCrashRecoveryHandler.backupState();
Michael Kolb8233fac2010-10-26 16:08:53 -07002092 }
2093
Michael Kolbf2055602011-04-09 17:20:03 -07002094 @Override
2095 public void setActiveTab(Tab tab) {
Michael Kolbcd424e92011-02-24 10:26:26 -08002096 // monkey protection against delayed start
2097 if (tab != null) {
2098 mTabControl.setCurrentTab(tab);
2099 // the tab is guaranteed to have a webview after setCurrentTab
2100 mUi.setActiveTab(tab);
2101 }
Michael Kolb8233fac2010-10-26 16:08:53 -07002102 }
2103
John Reck8bcafc12011-08-29 16:43:02 -07002104 protected void closeEmptyTab() {
Michael Kolb8233fac2010-10-26 16:08:53 -07002105 Tab current = mTabControl.getCurrentTab();
2106 if (current != null
2107 && current.getWebView().copyBackForwardList().getSize() == 0) {
John Reck8bcafc12011-08-29 16:43:02 -07002108 closeCurrentTab();
Michael Kolb8233fac2010-10-26 16:08:53 -07002109 }
2110 }
2111
John Reck26b18322011-06-21 13:08:58 -07002112 protected void reuseTab(Tab appTab, UrlData urlData) {
Michael Kolb8233fac2010-10-26 16:08:53 -07002113 // Dismiss the subwindow if applicable.
2114 dismissSubWindow(appTab);
2115 // Since we might kill the WebView, remove it from the
2116 // content view first.
2117 mUi.detachTab(appTab);
2118 // Recreate the main WebView after destroying the old one.
John Reck30c714c2010-12-16 17:30:34 -08002119 mTabControl.recreateWebView(appTab);
Michael Kolb8233fac2010-10-26 16:08:53 -07002120 // TODO: analyze why the remove and add are necessary
2121 mUi.attachTab(appTab);
2122 if (mTabControl.getCurrentTab() != appTab) {
Michael Kolbc831b632011-05-11 09:30:34 -07002123 switchToTab(appTab);
John Reck30c714c2010-12-16 17:30:34 -08002124 loadUrlDataIn(appTab, urlData);
Michael Kolb8233fac2010-10-26 16:08:53 -07002125 } else {
2126 // If the tab was the current tab, we have to attach
2127 // it to the view system again.
2128 setActiveTab(appTab);
John Reck30c714c2010-12-16 17:30:34 -08002129 loadUrlDataIn(appTab, urlData);
Michael Kolb8233fac2010-10-26 16:08:53 -07002130 }
2131 }
2132
2133 // Remove the sub window if it exists. Also called by TabControl when the
2134 // user clicks the 'X' to dismiss a sub window.
2135 public void dismissSubWindow(Tab tab) {
2136 removeSubWindow(tab);
2137 // dismiss the subwindow. This will destroy the WebView.
2138 tab.dismissSubWindow();
2139 getCurrentTopWebView().requestFocus();
2140 }
2141
2142 @Override
2143 public void removeSubWindow(Tab t) {
2144 if (t.getSubWebView() != null) {
2145 mUi.removeSubWindow(t.getSubViewContainer());
2146 }
2147 }
2148
2149 @Override
2150 public void attachSubWindow(Tab tab) {
2151 if (tab.getSubWebView() != null) {
2152 mUi.attachSubWindow(tab.getSubViewContainer());
2153 getCurrentTopWebView().requestFocus();
2154 }
2155 }
2156
Mathew Inwood29721c22011-06-29 17:55:24 +01002157 private Tab showPreloadedTab(final UrlData urlData) {
2158 if (!urlData.isPreloaded()) {
2159 return null;
2160 }
2161 final PreloadedTabControl tabControl = urlData.getPreloadedTab();
2162 final String sbQuery = urlData.getSearchBoxQueryToSubmit();
2163 if (sbQuery != null) {
Mathew Inwood9ad1eac2011-09-15 11:29:50 +01002164 if (!tabControl.searchBoxSubmit(sbQuery, urlData.mUrl, urlData.mHeaders)) {
Mathew Inwood29721c22011-06-29 17:55:24 +01002165 // Could not submit query. Fallback to regular tab creation
2166 tabControl.destroy();
2167 return null;
2168 }
2169 }
Michael Kolbff6a7482011-07-26 16:37:15 -07002170 // check tab count and make room for new tab
2171 if (!mTabControl.canCreateNewTab()) {
2172 Tab leastUsed = mTabControl.getLeastUsedTab(getCurrentTab());
2173 if (leastUsed != null) {
2174 closeTab(leastUsed);
2175 }
2176 }
Mathew Inwood29721c22011-06-29 17:55:24 +01002177 Tab t = tabControl.getTab();
Mathew Inwoode09305e2011-09-02 12:03:26 +01002178 t.refreshIdAfterPreload();
Mathew Inwood29721c22011-06-29 17:55:24 +01002179 mTabControl.addPreloadedTab(t);
2180 addTab(t);
2181 setActiveTab(t);
2182 return t;
2183 }
2184
Michael Kolb7bcafde2011-05-09 13:55:59 -07002185 // open a non inconito tab with the given url data
2186 // and set as active tab
2187 public Tab openTab(UrlData urlData) {
Mathew Inwood29721c22011-06-29 17:55:24 +01002188 Tab tab = showPreloadedTab(urlData);
2189 if (tab == null) {
2190 tab = createNewTab(false, true, true);
Michael Kolb14612442011-06-24 13:06:29 -07002191 if ((tab != null) && !urlData.isEmpty()) {
2192 loadUrlDataIn(tab, urlData);
2193 }
Michael Kolb7bcafde2011-05-09 13:55:59 -07002194 }
Mathew Inwood29721c22011-06-29 17:55:24 +01002195 return tab;
Michael Kolb7bcafde2011-05-09 13:55:59 -07002196 }
2197
Michael Kolb843510f2010-12-09 10:51:49 -08002198 @Override
2199 public Tab openTabToHomePage() {
Michael Kolb7bcafde2011-05-09 13:55:59 -07002200 return openTab(mSettings.getHomePage(), false, true, false);
Michael Kolb8233fac2010-10-26 16:08:53 -07002201 }
2202
Michael Kolb8233fac2010-10-26 16:08:53 -07002203 @Override
Michael Kolb519d2282011-05-09 17:03:19 -07002204 public Tab openIncognitoTab() {
2205 return openTab(INCOGNITO_URI, true, true, false);
2206 }
2207
2208 @Override
Michael Kolb7bcafde2011-05-09 13:55:59 -07002209 public Tab openTab(String url, boolean incognito, boolean setActive,
2210 boolean useCurrent) {
John Reck5949c662011-05-27 09:52:29 -07002211 return openTab(url, incognito, setActive, useCurrent, null);
2212 }
2213
2214 @Override
2215 public Tab openTab(String url, Tab parent, boolean setActive,
2216 boolean useCurrent) {
2217 return openTab(url, (parent != null) && parent.isPrivateBrowsingEnabled(),
2218 setActive, useCurrent, parent);
2219 }
2220
2221 public Tab openTab(String url, boolean incognito, boolean setActive,
2222 boolean useCurrent, Tab parent) {
Michael Kolb7bcafde2011-05-09 13:55:59 -07002223 Tab tab = createNewTab(incognito, setActive, useCurrent);
2224 if (tab != null) {
John Reck5949c662011-05-27 09:52:29 -07002225 if (parent != null && parent != tab) {
2226 parent.addChildTab(tab);
2227 }
Michael Kolb519d2282011-05-09 17:03:19 -07002228 if (url != null) {
John Reck26b18322011-06-21 13:08:58 -07002229 loadUrl(tab, url);
Michael Kolb519d2282011-05-09 17:03:19 -07002230 }
Michael Kolb8233fac2010-10-26 16:08:53 -07002231 }
Michael Kolb7bcafde2011-05-09 13:55:59 -07002232 return tab;
2233 }
2234
2235 // this method will attempt to create a new tab
2236 // incognito: private browsing tab
2237 // setActive: ste tab as current tab
2238 // useCurrent: if no new tab can be created, return current tab
2239 private Tab createNewTab(boolean incognito, boolean setActive,
2240 boolean useCurrent) {
2241 Tab tab = null;
2242 if (mTabControl.canCreateNewTab()) {
2243 tab = mTabControl.createNewTab(incognito);
2244 addTab(tab);
2245 if (setActive) {
2246 setActiveTab(tab);
2247 }
2248 } else {
2249 if (useCurrent) {
2250 tab = mTabControl.getCurrentTab();
John Reck26b18322011-06-21 13:08:58 -07002251 reuseTab(tab, null);
Michael Kolb7bcafde2011-05-09 13:55:59 -07002252 } else {
2253 mUi.showMaxTabsWarning();
2254 }
2255 }
2256 return tab;
Michael Kolb8233fac2010-10-26 16:08:53 -07002257 }
2258
John Reck2bc80422011-06-30 15:11:49 -07002259 @Override
2260 public SnapshotTab createNewSnapshotTab(long snapshotId, boolean setActive) {
2261 SnapshotTab tab = null;
2262 if (mTabControl.canCreateNewTab()) {
2263 tab = mTabControl.createSnapshotTab(snapshotId);
2264 addTab(tab);
2265 if (setActive) {
2266 setActiveTab(tab);
2267 }
2268 } else {
2269 mUi.showMaxTabsWarning();
John Reckd8c74522011-06-14 08:45:00 -07002270 }
2271 return tab;
2272 }
2273
Michael Kolb8233fac2010-10-26 16:08:53 -07002274 /**
Michael Kolbc831b632011-05-11 09:30:34 -07002275 * @param tab the tab to switch to
Michael Kolb8233fac2010-10-26 16:08:53 -07002276 * @return boolean True if we successfully switched to a different tab. If
2277 * the indexth tab is null, or if that tab is the same as
2278 * the current one, return false.
2279 */
2280 @Override
Michael Kolbc831b632011-05-11 09:30:34 -07002281 public boolean switchToTab(Tab tab) {
Michael Kolb8233fac2010-10-26 16:08:53 -07002282 Tab currentTab = mTabControl.getCurrentTab();
2283 if (tab == null || tab == currentTab) {
2284 return false;
2285 }
2286 setActiveTab(tab);
2287 return true;
2288 }
2289
2290 @Override
Michael Kolb8233fac2010-10-26 16:08:53 -07002291 public void closeCurrentTab() {
Michael Kolb2ae6ef72011-08-22 14:49:34 -07002292 closeCurrentTab(false);
2293 }
2294
2295 protected void closeCurrentTab(boolean andQuit) {
Michael Kolb8233fac2010-10-26 16:08:53 -07002296 if (mTabControl.getTabCount() == 1) {
John Reckbc490d22011-07-22 15:04:59 -07002297 mCrashRecoveryHandler.clearState();
Michael Kolbc1eeb122011-08-01 09:56:26 -07002298 mTabControl.removeTab(getCurrentTab());
John Reck958b2422010-12-03 17:56:17 -08002299 mActivity.finish();
Michael Kolb8233fac2010-10-26 16:08:53 -07002300 return;
2301 }
Michael Kolbc831b632011-05-11 09:30:34 -07002302 final Tab current = mTabControl.getCurrentTab();
2303 final int pos = mTabControl.getCurrentPosition();
2304 Tab newTab = current.getParent();
2305 if (newTab == null) {
2306 newTab = mTabControl.getTab(pos + 1);
2307 if (newTab == null) {
2308 newTab = mTabControl.getTab(pos - 1);
Michael Kolb8233fac2010-10-26 16:08:53 -07002309 }
2310 }
Michael Kolb2ae6ef72011-08-22 14:49:34 -07002311 if (andQuit) {
2312 mTabControl.setCurrentTab(newTab);
2313 closeTab(current);
2314 } else if (switchToTab(newTab)) {
Michael Kolb8233fac2010-10-26 16:08:53 -07002315 // Close window
2316 closeTab(current);
2317 }
2318 }
2319
2320 /**
2321 * Close the tab, remove its associated title bar, and adjust mTabControl's
2322 * current tab to a valid value.
2323 */
2324 @Override
2325 public void closeTab(Tab tab) {
Michael Kolb2d59c322011-01-25 13:18:55 -08002326 removeTab(tab);
Michael Kolb8233fac2010-10-26 16:08:53 -07002327 }
2328
Michael Kolb8233fac2010-10-26 16:08:53 -07002329 // Called when loading from context menu or LOAD_URL message
John Reck26b18322011-06-21 13:08:58 -07002330 protected void loadUrlFromContext(String url) {
2331 Tab tab = getCurrentTab();
2332 WebView view = tab != null ? tab.getWebView() : null;
Michael Kolb8233fac2010-10-26 16:08:53 -07002333 // In case the user enters nothing.
John Reck26b18322011-06-21 13:08:58 -07002334 if (url != null && url.length() != 0 && tab != null && view != null) {
Michael Kolb8233fac2010-10-26 16:08:53 -07002335 url = UrlUtils.smartUrlFilter(url);
2336 if (!view.getWebViewClient().shouldOverrideUrlLoading(view, url)) {
John Reck26b18322011-06-21 13:08:58 -07002337 loadUrl(tab, url);
Michael Kolb8233fac2010-10-26 16:08:53 -07002338 }
2339 }
2340 }
2341
2342 /**
2343 * Load the URL into the given WebView and update the title bar
2344 * to reflect the new load. Call this instead of WebView.loadUrl
2345 * directly.
2346 * @param view The WebView used to load url.
2347 * @param url The URL to load.
2348 */
John Reck71e51422011-07-01 16:49:28 -07002349 @Override
2350 public void loadUrl(Tab tab, String url) {
John Reck26b18322011-06-21 13:08:58 -07002351 loadUrl(tab, url, null);
2352 }
2353
2354 protected void loadUrl(Tab tab, String url, Map<String, String> headers) {
2355 if (tab != null) {
2356 dismissSubWindow(tab);
2357 tab.loadUrl(url, headers);
2358 }
Michael Kolb8233fac2010-10-26 16:08:53 -07002359 }
2360
2361 /**
2362 * Load UrlData into a Tab and update the title bar to reflect the new
2363 * load. Call this instead of UrlData.loadIn directly.
2364 * @param t The Tab used to load.
2365 * @param data The UrlData being loaded.
2366 */
2367 protected void loadUrlDataIn(Tab t, UrlData data) {
John Reck26b18322011-06-21 13:08:58 -07002368 if (data != null) {
2369 if (data.mVoiceIntent != null) {
2370 t.activateVoiceSearchMode(data.mVoiceIntent);
Michael Kolb14612442011-06-24 13:06:29 -07002371 } else if (data.isPreloaded()) {
2372 // this isn't called for preloaded tabs
John Reck26b18322011-06-21 13:08:58 -07002373 } else {
2374 loadUrl(t, data.mUrl, data.mHeaders);
2375 }
2376 }
Michael Kolb8233fac2010-10-26 16:08:53 -07002377 }
2378
John Reck30c714c2010-12-16 17:30:34 -08002379 @Override
2380 public void onUserCanceledSsl(Tab tab) {
John Reck30c714c2010-12-16 17:30:34 -08002381 // TODO: Figure out the "right" behavior
John Reckef654f12011-07-12 16:42:08 -07002382 if (tab.canGoBack()) {
2383 tab.goBack();
John Reck30c714c2010-12-16 17:30:34 -08002384 } else {
John Reckef654f12011-07-12 16:42:08 -07002385 tab.loadUrl(mSettings.getHomePage(), null);
John Reck30c714c2010-12-16 17:30:34 -08002386 }
Michael Kolb8233fac2010-10-26 16:08:53 -07002387 }
2388
2389 void goBackOnePageOrQuit() {
2390 Tab current = mTabControl.getCurrentTab();
2391 if (current == null) {
2392 /*
2393 * Instead of finishing the activity, simply push this to the back
2394 * of the stack and let ActivityManager to choose the foreground
2395 * activity. As BrowserActivity is singleTask, it will be always the
2396 * root of the task. So we can use either true or false for
2397 * moveTaskToBack().
2398 */
2399 mActivity.moveTaskToBack(true);
2400 return;
2401 }
John Reckef654f12011-07-12 16:42:08 -07002402 if (current.canGoBack()) {
2403 current.goBack();
Michael Kolb8233fac2010-10-26 16:08:53 -07002404 } else {
2405 // Check to see if we are closing a window that was created by
2406 // another window. If so, we switch back to that window.
Michael Kolbc831b632011-05-11 09:30:34 -07002407 Tab parent = current.getParent();
Michael Kolb8233fac2010-10-26 16:08:53 -07002408 if (parent != null) {
Michael Kolbc831b632011-05-11 09:30:34 -07002409 switchToTab(parent);
Michael Kolb8233fac2010-10-26 16:08:53 -07002410 // Now we close the other tab
2411 closeTab(current);
2412 } else {
Michael Kolbe28b3472011-08-04 16:54:31 -07002413 if ((current.getAppId() != null) || current.closeOnBack()) {
Michael Kolb2ae6ef72011-08-22 14:49:34 -07002414 closeCurrentTab(true);
Michael Kolbe28b3472011-08-04 16:54:31 -07002415 }
Michael Kolb8233fac2010-10-26 16:08:53 -07002416 /*
2417 * Instead of finishing the activity, simply push this to the back
2418 * of the stack and let ActivityManager to choose the foreground
2419 * activity. As BrowserActivity is singleTask, it will be always the
2420 * root of the task. So we can use either true or false for
2421 * moveTaskToBack().
2422 */
2423 mActivity.moveTaskToBack(true);
2424 }
2425 }
2426 }
2427
2428 /**
2429 * Feed the previously stored results strings to the BrowserProvider so that
2430 * the SearchDialog will show them instead of the standard searches.
2431 * @param result String to show on the editable line of the SearchDialog.
2432 */
2433 @Override
2434 public void showVoiceSearchResults(String result) {
2435 ContentProviderClient client = mActivity.getContentResolver()
2436 .acquireContentProviderClient(Browser.BOOKMARKS_URI);
2437 ContentProvider prov = client.getLocalContentProvider();
2438 BrowserProvider bp = (BrowserProvider) prov;
2439 bp.setQueryResults(mTabControl.getCurrentTab().getVoiceSearchResults());
2440 client.release();
2441
2442 Bundle bundle = createGoogleSearchSourceBundle(
2443 GOOGLE_SEARCH_SOURCE_SEARCHKEY);
2444 bundle.putBoolean(SearchManager.CONTEXT_IS_VOICE, true);
2445 startSearch(result, false, bundle, false);
2446 }
2447
2448 private void startSearch(String initialQuery, boolean selectInitialQuery,
2449 Bundle appSearchData, boolean globalSearch) {
2450 if (appSearchData == null) {
2451 appSearchData = createGoogleSearchSourceBundle(
2452 GOOGLE_SEARCH_SOURCE_TYPE);
2453 }
2454
2455 SearchEngine searchEngine = mSettings.getSearchEngine();
2456 if (searchEngine != null && !searchEngine.supportsVoiceSearch()) {
2457 appSearchData.putBoolean(SearchManager.DISABLE_VOICE_SEARCH, true);
2458 }
2459 mActivity.startSearch(initialQuery, selectInitialQuery, appSearchData,
2460 globalSearch);
2461 }
2462
2463 private Bundle createGoogleSearchSourceBundle(String source) {
2464 Bundle bundle = new Bundle();
2465 bundle.putString(Search.SOURCE, source);
2466 return bundle;
2467 }
2468
2469 /**
Michael Kolb0035fad2011-03-14 13:25:28 -07002470 * helper method for key handler
2471 * returns the current tab if it can't advance
2472 */
Michael Kolbc831b632011-05-11 09:30:34 -07002473 private Tab getNextTab() {
2474 return mTabControl.getTab(Math.min(mTabControl.getTabCount() - 1,
2475 mTabControl.getCurrentPosition() + 1));
Michael Kolb0035fad2011-03-14 13:25:28 -07002476 }
2477
2478 /**
2479 * helper method for key handler
2480 * returns the current tab if it can't advance
2481 */
Michael Kolbc831b632011-05-11 09:30:34 -07002482 private Tab getPrevTab() {
2483 return mTabControl.getTab(Math.max(0,
2484 mTabControl.getCurrentPosition() - 1));
Michael Kolb0035fad2011-03-14 13:25:28 -07002485 }
2486
2487 /**
Michael Kolb8233fac2010-10-26 16:08:53 -07002488 * handle key events in browser
2489 *
2490 * @param keyCode
2491 * @param event
2492 * @return true if handled, false to pass to super
2493 */
2494 boolean onKeyDown(int keyCode, KeyEvent event) {
Cary Clark160bbb92011-01-10 11:17:07 -05002495 boolean noModifiers = event.hasNoModifiers();
Michael Kolb8233fac2010-10-26 16:08:53 -07002496 // Even if MENU is already held down, we need to call to super to open
2497 // the IME on long press.
Michael Kolbdc2ee1b2011-02-14 14:34:40 -08002498 if (!noModifiers
2499 && ((KeyEvent.KEYCODE_MENU == keyCode)
2500 || (KeyEvent.KEYCODE_CTRL_LEFT == keyCode)
2501 || (KeyEvent.KEYCODE_CTRL_RIGHT == keyCode))) {
Michael Kolb8233fac2010-10-26 16:08:53 -07002502 mMenuIsDown = true;
2503 return false;
2504 }
Michael Kolb8233fac2010-10-26 16:08:53 -07002505
Cary Clark8ff8c662010-12-29 15:03:05 -05002506 WebView webView = getCurrentTopWebView();
John Reckef654f12011-07-12 16:42:08 -07002507 Tab tab = getCurrentTab();
2508 if (webView == null || tab == null) return false;
Cary Clark8ff8c662010-12-29 15:03:05 -05002509
Cary Clark160bbb92011-01-10 11:17:07 -05002510 boolean ctrl = event.hasModifiers(KeyEvent.META_CTRL_ON);
2511 boolean shift = event.hasModifiers(KeyEvent.META_SHIFT_ON);
Cary Clark8ff8c662010-12-29 15:03:05 -05002512
Michael Kolb8233fac2010-10-26 16:08:53 -07002513 switch(keyCode) {
Michael Kolb0035fad2011-03-14 13:25:28 -07002514 case KeyEvent.KEYCODE_TAB:
2515 if (event.isCtrlPressed()) {
2516 if (event.isShiftPressed()) {
2517 // prev tab
Michael Kolbc831b632011-05-11 09:30:34 -07002518 switchToTab(getPrevTab());
Michael Kolb0035fad2011-03-14 13:25:28 -07002519 } else {
2520 // next tab
Michael Kolbc831b632011-05-11 09:30:34 -07002521 switchToTab(getNextTab());
Michael Kolb0035fad2011-03-14 13:25:28 -07002522 }
2523 return true;
2524 }
2525 break;
Michael Kolb8233fac2010-10-26 16:08:53 -07002526 case KeyEvent.KEYCODE_SPACE:
2527 // WebView/WebTextView handle the keys in the KeyDown. As
2528 // the Activity's shortcut keys are only handled when WebView
2529 // doesn't, have to do it in onKeyDown instead of onKeyUp.
Cary Clark160bbb92011-01-10 11:17:07 -05002530 if (shift) {
Michael Kolb8233fac2010-10-26 16:08:53 -07002531 pageUp();
Cary Clark160bbb92011-01-10 11:17:07 -05002532 } else if (noModifiers) {
Michael Kolb8233fac2010-10-26 16:08:53 -07002533 pageDown();
2534 }
2535 return true;
2536 case KeyEvent.KEYCODE_BACK:
Cary Clark160bbb92011-01-10 11:17:07 -05002537 if (!noModifiers) break;
John Recke6bf4ab2011-02-24 15:48:05 -08002538 event.startTracking();
2539 return true;
Michael Kolbe9e1d4a2011-07-14 15:02:17 -07002540 case KeyEvent.KEYCODE_FORWARD:
2541 if (!noModifiers) break;
2542 tab.goForward();
2543 return true;
Cary Clark8ff8c662010-12-29 15:03:05 -05002544 case KeyEvent.KEYCODE_DPAD_LEFT:
2545 if (ctrl) {
John Reckef654f12011-07-12 16:42:08 -07002546 tab.goBack();
Cary Clark8ff8c662010-12-29 15:03:05 -05002547 return true;
2548 }
2549 break;
2550 case KeyEvent.KEYCODE_DPAD_RIGHT:
2551 if (ctrl) {
John Reckef654f12011-07-12 16:42:08 -07002552 tab.goForward();
Cary Clark8ff8c662010-12-29 15:03:05 -05002553 return true;
2554 }
2555 break;
2556 case KeyEvent.KEYCODE_A:
2557 if (ctrl) {
2558 webView.selectAll();
2559 return true;
2560 }
2561 break;
Michael Kolba4183062011-01-16 10:43:21 -08002562// case KeyEvent.KEYCODE_B: // menu
Cary Clark8ff8c662010-12-29 15:03:05 -05002563 case KeyEvent.KEYCODE_C:
2564 if (ctrl) {
2565 webView.copySelection();
2566 return true;
2567 }
2568 break;
Michael Kolba4183062011-01-16 10:43:21 -08002569// case KeyEvent.KEYCODE_D: // menu
Cary Clark8ff8c662010-12-29 15:03:05 -05002570// case KeyEvent.KEYCODE_E: // in Chrome: puts '?' in URL bar
Michael Kolba4183062011-01-16 10:43:21 -08002571// case KeyEvent.KEYCODE_F: // menu
Cary Clark8ff8c662010-12-29 15:03:05 -05002572// case KeyEvent.KEYCODE_G: // in Chrome: finds next match
Michael Kolba4183062011-01-16 10:43:21 -08002573// case KeyEvent.KEYCODE_H: // menu
Cary Clark8ff8c662010-12-29 15:03:05 -05002574// case KeyEvent.KEYCODE_I: // unused
Michael Kolba4183062011-01-16 10:43:21 -08002575// case KeyEvent.KEYCODE_J: // menu
Cary Clark8ff8c662010-12-29 15:03:05 -05002576// case KeyEvent.KEYCODE_K: // in Chrome: puts '?' in URL bar
Michael Kolba4183062011-01-16 10:43:21 -08002577// case KeyEvent.KEYCODE_L: // menu
Cary Clark8ff8c662010-12-29 15:03:05 -05002578// case KeyEvent.KEYCODE_M: // unused
2579// case KeyEvent.KEYCODE_N: // in Chrome: new window
2580// case KeyEvent.KEYCODE_O: // in Chrome: open file
2581// case KeyEvent.KEYCODE_P: // in Chrome: print page
2582// case KeyEvent.KEYCODE_Q: // unused
Michael Kolbdc2ee1b2011-02-14 14:34:40 -08002583// case KeyEvent.KEYCODE_R:
Cary Clark8ff8c662010-12-29 15:03:05 -05002584// case KeyEvent.KEYCODE_S: // in Chrome: saves page
2585 case KeyEvent.KEYCODE_T:
Michael Kolbdc2ee1b2011-02-14 14:34:40 -08002586 // we can't use the ctrl/shift flags, they check for
2587 // exclusive use of a modifier
2588 if (event.isCtrlPressed()) {
Cary Clark8ff8c662010-12-29 15:03:05 -05002589 if (event.isShiftPressed()) {
Michael Kolb519d2282011-05-09 17:03:19 -07002590 openIncognitoTab();
Cary Clark8ff8c662010-12-29 15:03:05 -05002591 } else {
2592 openTabToHomePage();
2593 }
2594 return true;
2595 }
2596 break;
2597// case KeyEvent.KEYCODE_U: // in Chrome: opens source of page
2598// case KeyEvent.KEYCODE_V: // text view intercepts to paste
Michael Kolb5ae15bd2011-08-16 17:09:27 -07002599// case KeyEvent.KEYCODE_W: // menu
Cary Clark8ff8c662010-12-29 15:03:05 -05002600// case KeyEvent.KEYCODE_X: // text view intercepts to cut
2601// case KeyEvent.KEYCODE_Y: // unused
2602// case KeyEvent.KEYCODE_Z: // unused
Michael Kolb8233fac2010-10-26 16:08:53 -07002603 }
Michael Kolbdc2ee1b2011-02-14 14:34:40 -08002604 // it is a regular key and webview is not null
2605 return mUi.dispatchKey(keyCode, event);
Michael Kolb8233fac2010-10-26 16:08:53 -07002606 }
2607
John Recke6bf4ab2011-02-24 15:48:05 -08002608 boolean onKeyLongPress(int keyCode, KeyEvent event) {
2609 switch(keyCode) {
2610 case KeyEvent.KEYCODE_BACK:
John Reck3ba45532011-08-11 16:26:53 -07002611 if (mUi.isWebShowing()) {
John Recke6bf4ab2011-02-24 15:48:05 -08002612 bookmarksOrHistoryPicker(true);
2613 return true;
2614 }
2615 break;
2616 }
2617 return false;
2618 }
2619
Michael Kolb8233fac2010-10-26 16:08:53 -07002620 boolean onKeyUp(int keyCode, KeyEvent event) {
Michael Kolb2814a362011-05-19 15:49:41 -07002621 if (KeyEvent.KEYCODE_MENU == keyCode) {
2622 mMenuIsDown = false;
2623 if (event.isTracking() && !event.isCanceled()) {
Michael Kolb4bd767d2011-05-27 11:33:55 -07002624 return onMenuKey();
Michael Kolb2814a362011-05-19 15:49:41 -07002625 }
2626 }
Cary Clark160bbb92011-01-10 11:17:07 -05002627 if (!event.hasNoModifiers()) return false;
Michael Kolb8233fac2010-10-26 16:08:53 -07002628 switch(keyCode) {
Michael Kolb8233fac2010-10-26 16:08:53 -07002629 case KeyEvent.KEYCODE_BACK:
2630 if (event.isTracking() && !event.isCanceled()) {
2631 onBackKey();
2632 return true;
2633 }
2634 break;
2635 }
2636 return false;
2637 }
2638
2639 public boolean isMenuDown() {
2640 return mMenuIsDown;
2641 }
2642
Ben Murdoch8029a772010-11-16 11:58:21 +00002643 public void setupAutoFill(Message message) {
2644 // Open the settings activity at the AutoFill profile fragment so that
2645 // the user can create a new profile. When they return, we will dispatch
2646 // the message so that we can autofill the form using their new profile.
2647 Intent intent = new Intent(mActivity, BrowserPreferencesPage.class);
2648 intent.putExtra(PreferenceActivity.EXTRA_SHOW_FRAGMENT,
2649 AutoFillSettingsFragment.class.getName());
2650 mAutoFillSetupMessage = message;
2651 mActivity.startActivityForResult(intent, AUTOFILL_SETUP);
2652 }
John Reckb3417f02011-01-14 11:01:05 -08002653
2654 @Override
Narayan Kamath5119edd2011-02-23 15:49:17 +00002655 public void registerDropdownChangeListener(DropdownChangeListener d) {
2656 mUi.registerDropdownChangeListener(d);
2657 }
Michael Kolbfbc579a2011-07-07 15:59:33 -07002658
2659 public boolean onSearchRequested() {
2660 mUi.editUrl(false);
2661 return true;
2662 }
2663
John Reck1cf4b792011-07-26 10:22:22 -07002664 @Override
2665 public boolean shouldCaptureThumbnails() {
2666 return mUi.shouldCaptureThumbnails();
2667 }
2668
Michael Kolbc3af0672011-08-09 10:24:41 -07002669 @Override
2670 public void setBlockEvents(boolean block) {
2671 mBlockEvents = block;
2672 }
2673
2674 public boolean dispatchKeyEvent(KeyEvent event) {
Michael Kolb87357642011-08-24 14:19:18 -07002675 return mBlockEvents;
Michael Kolbc3af0672011-08-09 10:24:41 -07002676 }
2677
2678 public boolean dispatchKeyShortcutEvent(KeyEvent event) {
Michael Kolb87357642011-08-24 14:19:18 -07002679 return mBlockEvents;
Michael Kolbc3af0672011-08-09 10:24:41 -07002680 }
2681
2682 public boolean dispatchTouchEvent(MotionEvent ev) {
Michael Kolb87357642011-08-24 14:19:18 -07002683 return mBlockEvents;
Michael Kolbc3af0672011-08-09 10:24:41 -07002684 }
2685
2686 public boolean dispatchTrackballEvent(MotionEvent ev) {
Michael Kolb87357642011-08-24 14:19:18 -07002687 return mBlockEvents;
Michael Kolbc3af0672011-08-09 10:24:41 -07002688 }
2689
2690 public boolean dispatchGenericMotionEvent(MotionEvent ev) {
Michael Kolb87357642011-08-24 14:19:18 -07002691 return mBlockEvents;
Michael Kolbc3af0672011-08-09 10:24:41 -07002692 }
2693
Michael Kolb8233fac2010-10-26 16:08:53 -07002694}