| /* |
| * Copyright (C) 2010 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.browser; |
| |
| import android.app.Activity; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.res.Configuration; |
| import android.content.res.Resources; |
| import android.graphics.Bitmap; |
| import android.graphics.BitmapFactory; |
| import android.graphics.Color; |
| import android.graphics.drawable.BitmapDrawable; |
| import android.graphics.drawable.Drawable; |
| import android.graphics.drawable.LayerDrawable; |
| import android.graphics.drawable.PaintDrawable; |
| import android.os.Bundle; |
| import android.os.Handler; |
| import android.os.Message; |
| import android.text.TextUtils; |
| import android.view.ActionMode; |
| import android.view.Gravity; |
| import android.view.LayoutInflater; |
| import android.view.Menu; |
| import android.view.MenuItem; |
| import android.view.MotionEvent; |
| import android.view.View; |
| import android.view.View.OnClickListener; |
| import android.view.ViewGroup; |
| import android.view.ViewGroup.LayoutParams; |
| import android.view.Window; |
| import android.view.WindowManager; |
| import android.view.inputmethod.InputMethodManager; |
| import android.webkit.WebChromeClient.CustomViewCallback; |
| import android.widget.FrameLayout; |
| import android.widget.ImageButton; |
| import android.widget.LinearLayout; |
| import android.widget.Toast; |
| |
| import com.android.browser.R; |
| import com.android.browser.Tab.SecurityState; |
| |
| import org.codeaurora.swe.WebView; |
| |
| import java.util.List; |
| |
| /** |
| * UI interface definitions |
| */ |
| public abstract class BaseUi implements UI { |
| |
| private static final String LOGTAG = "BaseUi"; |
| |
| protected static final FrameLayout.LayoutParams COVER_SCREEN_PARAMS = |
| new FrameLayout.LayoutParams( |
| ViewGroup.LayoutParams.MATCH_PARENT, |
| ViewGroup.LayoutParams.MATCH_PARENT); |
| |
| protected static final FrameLayout.LayoutParams COVER_SCREEN_GRAVITY_CENTER = |
| new FrameLayout.LayoutParams( |
| ViewGroup.LayoutParams.MATCH_PARENT, |
| ViewGroup.LayoutParams.MATCH_PARENT, |
| Gravity.CENTER); |
| |
| private static final int MSG_HIDE_TITLEBAR = 1; |
| public static final int HIDE_TITLEBAR_DELAY = 1500; // in ms |
| |
| Activity mActivity; |
| UiController mUiController; |
| TabControl mTabControl; |
| protected Tab mActiveTab; |
| private InputMethodManager mInputManager; |
| |
| private Drawable mLockIconSecure; |
| private Drawable mLockIconMixed; |
| protected Drawable mGenericFavicon; |
| |
| protected FrameLayout mContentView; |
| protected FrameLayout mCustomViewContainer; |
| protected FrameLayout mFullscreenContainer; |
| private FrameLayout mFixedTitlebarContainer; |
| |
| private View mCustomView; |
| private CustomViewCallback mCustomViewCallback; |
| private int mOriginalOrientation; |
| |
| private LinearLayout mErrorConsoleContainer = null; |
| |
| private UrlBarAutoShowManager mUrlBarAutoShowManager; |
| |
| private Toast mStopToast; |
| |
| // the default <video> poster |
| private Bitmap mDefaultVideoPoster; |
| // the video progress view |
| private View mVideoProgressView; |
| |
| private boolean mActivityPaused; |
| protected boolean mUseQuickControls; |
| protected TitleBar mTitleBar; |
| private NavigationBarBase mNavigationBar; |
| protected PieControl mPieControl; |
| private boolean mBlockFocusAnimations; |
| |
| public BaseUi(Activity browser, UiController controller) { |
| mActivity = browser; |
| mUiController = controller; |
| mTabControl = controller.getTabControl(); |
| Resources res = mActivity.getResources(); |
| mInputManager = (InputMethodManager) |
| browser.getSystemService(Activity.INPUT_METHOD_SERVICE); |
| mLockIconSecure = res.getDrawable(R.drawable.ic_secure_holo_dark); |
| mLockIconMixed = res.getDrawable(R.drawable.ic_secure_partial_holo_dark); |
| FrameLayout frameLayout = (FrameLayout) mActivity.getWindow() |
| .getDecorView().findViewById(android.R.id.content); |
| LayoutInflater.from(mActivity) |
| .inflate(R.layout.custom_screen, frameLayout); |
| mFixedTitlebarContainer = (FrameLayout) frameLayout.findViewById( |
| R.id.fixed_titlebar_container); |
| mContentView = (FrameLayout) frameLayout.findViewById( |
| R.id.main_content); |
| mCustomViewContainer = (FrameLayout) frameLayout.findViewById( |
| R.id.fullscreen_custom_content); |
| mErrorConsoleContainer = (LinearLayout) frameLayout |
| .findViewById(R.id.error_console); |
| setFullscreen(BrowserSettings.getInstance().useFullscreen()); |
| mGenericFavicon = res.getDrawable( |
| R.drawable.app_web_browser_sm); |
| mTitleBar = new TitleBar(mActivity, mUiController, this, |
| mContentView); |
| mTitleBar.setProgress(100); |
| mNavigationBar = mTitleBar.getNavigationBar(); |
| mUrlBarAutoShowManager = new UrlBarAutoShowManager(this); |
| } |
| |
| private void cancelStopToast() { |
| if (mStopToast != null) { |
| mStopToast.cancel(); |
| mStopToast = null; |
| } |
| } |
| |
| // lifecycle |
| |
| public void onPause() { |
| if (isCustomViewShowing()) { |
| onHideCustomView(); |
| } |
| cancelStopToast(); |
| mActivityPaused = true; |
| } |
| |
| public void onResume() { |
| mActivityPaused = false; |
| // check if we exited without setting active tab |
| // b: 5188145 |
| final Tab ct = mTabControl.getCurrentTab(); |
| if (ct != null) { |
| setActiveTab(ct); |
| } |
| mTitleBar.onResume(); |
| } |
| |
| protected boolean isActivityPaused() { |
| return mActivityPaused; |
| } |
| |
| public void onConfigurationChanged(Configuration config) { |
| } |
| |
| public Activity getActivity() { |
| return mActivity; |
| } |
| |
| // key handling |
| |
| @Override |
| public boolean onBackKey() { |
| if (mCustomView != null) { |
| mUiController.hideCustomView(); |
| return true; |
| } |
| return false; |
| } |
| |
| @Override |
| public boolean onMenuKey() { |
| return false; |
| } |
| |
| @Override |
| public void setUseQuickControls(boolean useQuickControls) { |
| mUseQuickControls = useQuickControls; |
| mTitleBar.setUseQuickControls(mUseQuickControls); |
| if (useQuickControls) { |
| mPieControl = new PieControl(mActivity, mUiController, this); |
| mPieControl.attachToContainer(mContentView); |
| } else { |
| if (mPieControl != null) { |
| mPieControl.removeFromContainer(mContentView); |
| } |
| } |
| updateUrlBarAutoShowManagerTarget(); |
| } |
| |
| // Tab callbacks |
| @Override |
| public void onTabDataChanged(Tab tab) { |
| setUrlTitle(tab); |
| setFavicon(tab); |
| updateLockIconToLatest(tab); |
| updateNavigationState(tab); |
| mTitleBar.onTabDataChanged(tab); |
| mNavigationBar.onTabDataChanged(tab); |
| onProgressChanged(tab); |
| } |
| |
| @Override |
| public void onProgressChanged(Tab tab) { |
| int progress = tab.getLoadProgress(); |
| if (tab.inForeground()) { |
| mTitleBar.setProgress(progress); |
| } |
| } |
| |
| @Override |
| public void bookmarkedStatusHasChanged(Tab tab) { |
| if (tab.inForeground()) { |
| boolean isBookmark = tab.isBookmarkedSite(); |
| mNavigationBar.setCurrentUrlIsBookmark(isBookmark); |
| } |
| } |
| |
| @Override |
| public void onPageStopped(Tab tab) { |
| cancelStopToast(); |
| if (tab.inForeground()) { |
| mStopToast = Toast |
| .makeText(mActivity, R.string.stopping, Toast.LENGTH_SHORT); |
| mStopToast.show(); |
| } |
| } |
| |
| @Override |
| public boolean needsRestoreAllTabs() { |
| return true; |
| } |
| |
| @Override |
| public void addTab(Tab tab) { |
| } |
| |
| @Override |
| public void setActiveTab(final Tab tab) { |
| if (tab == null) return; |
| Tab tabToRemove = null; |
| BrowserWebView webViewToWaitFor = null; |
| |
| // block unnecessary focus change animations during tab switch |
| mBlockFocusAnimations = true; |
| mHandler.removeMessages(MSG_HIDE_TITLEBAR); |
| if ((tab != mActiveTab) && (mActiveTab != null)) { |
| tabToRemove = mActiveTab; |
| WebView web = mActiveTab.getWebView(); |
| if (web != null) { |
| web.setOnTouchListener(null); |
| } |
| } |
| mActiveTab = tab; |
| BrowserWebView web = (BrowserWebView) mActiveTab.getWebView(); |
| updateUrlBarAutoShowManagerTarget(); |
| attachTabToContentView(tab); |
| if (web != null) { |
| // Request focus on the top window. |
| if (mUseQuickControls) { |
| mPieControl.forceToTop(mContentView); |
| web.setTitleBar(null); |
| mTitleBar.hide(); |
| } else { |
| web.setTitleBar(mTitleBar); |
| mTitleBar.onScrollChanged(); |
| } |
| webViewToWaitFor = web; |
| } |
| mTitleBar.bringToFront(); |
| tab.getTopWindow().requestFocus(); |
| setShouldShowErrorConsole(tab, mUiController.shouldShowErrorConsole()); |
| onTabDataChanged(tab); |
| onProgressChanged(tab); |
| mNavigationBar.setIncognitoMode(tab.isPrivateBrowsingEnabled()); |
| mBlockFocusAnimations = false; |
| |
| scheduleRemoveTab(tabToRemove, webViewToWaitFor); |
| } |
| |
| Tab mTabToRemove = null; |
| BrowserWebView mWebViewToWaitFor = null; |
| int mNumRemoveTries = 0; |
| |
| protected void scheduleRemoveTab(Tab tab, BrowserWebView webview) { |
| //remove previously scehduled tab |
| if (mTabToRemove != null) { |
| removeTabFromContentView(mTabToRemove); |
| mTabToRemove.performPostponedDestroy(); |
| } |
| mTabToRemove = tab; |
| mWebViewToWaitFor = webview; |
| mNumRemoveTries = 0; |
| |
| if (mTabToRemove != null) { |
| mTabToRemove.postponeDestroy(); |
| android.os.Handler handler = mTitleBar.getHandler(); |
| handler.postDelayed(new Runnable() { |
| public void run() { |
| tryRemoveTab(); |
| } |
| }, 33); /*we know at this point for sure that the new tab is not ready |
| since it's just getting created. It'll be at least 1 frame's |
| time that the new tab will painting something, and another 1 |
| frame's time that we're sure the swap is done. It is possible |
| that the swap is finish right the way, but unless use use EGL |
| fence we can never be sure. So wait for 2 frames before trying |
| to remove the tab. It is possible that the tab is still not |
| ready after 2 frames, but this is good enough.*/ |
| } |
| } |
| |
| protected void tryRemoveTab() { |
| mNumRemoveTries++; |
| if (mNumRemoveTries < 20 && mWebViewToWaitFor != null) { |
| if (!mWebViewToWaitFor.isReady()) { |
| android.os.Handler handler = mTitleBar.getHandler(); |
| handler.postDelayed(new Runnable() { |
| public void run() { |
| tryRemoveTab(); |
| } |
| }, 33); /*if the new tab is still not ready, wait another 2 frames |
| before trying again. 1 frame for the tab to render the first |
| frame, another 1 frame to make sure the swap is done*/ |
| return; |
| } |
| } |
| if (mTabToRemove != null) { |
| removeTabFromContentView(mTabToRemove); |
| mTabToRemove.performPostponedDestroy(); |
| } |
| mTabToRemove = null; |
| mWebViewToWaitFor = null; |
| } |
| |
| protected void updateUrlBarAutoShowManagerTarget() { |
| WebView web = mActiveTab != null ? mActiveTab.getWebView() : null; |
| if (!mUseQuickControls && web instanceof BrowserWebView) { |
| mUrlBarAutoShowManager.setTarget((BrowserWebView) web); |
| } else { |
| mUrlBarAutoShowManager.setTarget(null); |
| } |
| } |
| |
| Tab getActiveTab() { |
| return mActiveTab; |
| } |
| |
| @Override |
| public void updateTabs(List<Tab> tabs) { |
| } |
| |
| @Override |
| public void removeTab(Tab tab) { |
| if (mActiveTab == tab) { |
| removeTabFromContentView(tab); |
| mActiveTab = null; |
| } |
| } |
| |
| @Override |
| public void detachTab(Tab tab) { |
| removeTabFromContentView(tab); |
| } |
| |
| @Override |
| public void attachTab(Tab tab) { |
| attachTabToContentView(tab); |
| } |
| |
| protected void attachTabToContentView(Tab tab) { |
| if ((tab == null) || (tab.getWebView() == null)) { |
| return; |
| } |
| View container = tab.getViewContainer(); |
| WebView mainView = tab.getWebView(); |
| // Attach the WebView to the container and then attach the |
| // container to the content view. |
| FrameLayout wrapper = |
| (FrameLayout) container.findViewById(R.id.webview_wrapper); |
| ViewGroup parent = (ViewGroup) mainView.getParent(); |
| if (parent != wrapper) { |
| if (parent != null) { |
| parent.removeView(mainView); |
| } |
| wrapper.addView(mainView); |
| } |
| parent = (ViewGroup) container.getParent(); |
| if (parent != mContentView) { |
| if (parent != null) { |
| parent.removeView(container); |
| } |
| mContentView.addView(container, COVER_SCREEN_PARAMS); |
| } |
| mUiController.attachSubWindow(tab); |
| } |
| |
| private void removeTabFromContentView(Tab tab) { |
| hideTitleBar(); |
| // Remove the container that contains the main WebView. |
| WebView mainView = tab.getWebView(); |
| View container = tab.getViewContainer(); |
| if (mainView == null) { |
| return; |
| } |
| // Remove the container from the content and then remove the |
| // WebView from the container. This will trigger a focus change |
| // needed by WebView. |
| FrameLayout wrapper = |
| (FrameLayout) container.findViewById(R.id.webview_wrapper); |
| wrapper.removeView(mainView); |
| mContentView.removeView(container); |
| mUiController.endActionMode(); |
| mUiController.removeSubWindow(tab); |
| ErrorConsoleView errorConsole = tab.getErrorConsole(false); |
| if (errorConsole != null) { |
| mErrorConsoleContainer.removeView(errorConsole); |
| } |
| } |
| |
| @Override |
| public void onSetWebView(Tab tab, WebView webView) { |
| View container = tab.getViewContainer(); |
| if (container == null) { |
| // The tab consists of a container view, which contains the main |
| // WebView, as well as any other UI elements associated with the tab. |
| container = mActivity.getLayoutInflater().inflate(R.layout.tab, |
| mContentView, false); |
| tab.setViewContainer(container); |
| } |
| if (tab.getWebView() != webView) { |
| // Just remove the old one. |
| FrameLayout wrapper = |
| (FrameLayout) container.findViewById(R.id.webview_wrapper); |
| wrapper.removeView(tab.getWebView()); |
| } |
| } |
| |
| /** |
| * create a sub window container and webview for the tab |
| * Note: this methods operates through side-effects for now |
| * it sets both the subView and subViewContainer for the given tab |
| * @param tab tab to create the sub window for |
| * @param subView webview to be set as a subwindow for the tab |
| */ |
| @Override |
| public void createSubWindow(Tab tab, WebView subView) { |
| View subViewContainer = mActivity.getLayoutInflater().inflate( |
| R.layout.browser_subwindow, null); |
| ViewGroup inner = (ViewGroup) subViewContainer |
| .findViewById(R.id.inner_container); |
| inner.addView(subView, new LayoutParams(LayoutParams.MATCH_PARENT, |
| LayoutParams.MATCH_PARENT)); |
| final ImageButton cancel = (ImageButton) subViewContainer |
| .findViewById(R.id.subwindow_close); |
| final WebView cancelSubView = subView; |
| cancel.setOnClickListener(new OnClickListener() { |
| @Override |
| public void onClick(View v) { |
| ((BrowserWebView) cancelSubView).getWebChromeClient().onCloseWindow(cancelSubView); |
| } |
| }); |
| tab.setSubWebView(subView); |
| tab.setSubViewContainer(subViewContainer); |
| } |
| |
| /** |
| * Remove the sub window from the content view. |
| */ |
| @Override |
| public void removeSubWindow(View subviewContainer) { |
| mContentView.removeView(subviewContainer); |
| mUiController.endActionMode(); |
| } |
| |
| /** |
| * Attach the sub window to the content view. |
| */ |
| @Override |
| public void attachSubWindow(View container) { |
| if (container.getParent() != null) { |
| // already attached, remove first |
| ((ViewGroup) container.getParent()).removeView(container); |
| } |
| mContentView.addView(container, COVER_SCREEN_PARAMS); |
| } |
| |
| protected void refreshWebView() { |
| WebView web = getWebView(); |
| if (web != null) { |
| web.invalidate(); |
| } |
| } |
| |
| public void editUrl(boolean clearInput, boolean forceIME) { |
| if (mUiController.isInCustomActionMode()) { |
| mUiController.endActionMode(); |
| } |
| showTitleBar(); |
| if ((getActiveTab() != null) && !getActiveTab().isSnapshot()) { |
| mNavigationBar.startEditingUrl(clearInput, forceIME); |
| } |
| } |
| |
| boolean canShowTitleBar() { |
| return !isTitleBarShowing() |
| && !isActivityPaused() |
| && (getActiveTab() != null) |
| && (getWebView() != null) |
| && !mUiController.isInCustomActionMode(); |
| } |
| |
| protected void showTitleBar() { |
| mHandler.removeMessages(MSG_HIDE_TITLEBAR); |
| if (canShowTitleBar()) { |
| mTitleBar.show(); |
| } |
| } |
| |
| protected void hideTitleBar() { |
| if (mTitleBar.isShowing()) { |
| mTitleBar.hide(); |
| } |
| } |
| |
| protected boolean isTitleBarShowing() { |
| return mTitleBar.isShowing(); |
| } |
| |
| public boolean isEditingUrl() { |
| return mTitleBar.isEditingUrl(); |
| } |
| |
| public void stopEditingUrl() { |
| mTitleBar.getNavigationBar().stopEditingUrl(); |
| } |
| |
| public TitleBar getTitleBar() { |
| return mTitleBar; |
| } |
| |
| @Override |
| public void showComboView(ComboViews startingView, Bundle extras) { |
| Intent intent = new Intent(mActivity, ComboViewActivity.class); |
| intent.putExtra(ComboViewActivity.EXTRA_INITIAL_VIEW, startingView.name()); |
| intent.putExtra(ComboViewActivity.EXTRA_COMBO_ARGS, extras); |
| Tab t = getActiveTab(); |
| if (t != null) { |
| intent.putExtra(ComboViewActivity.EXTRA_CURRENT_URL, t.getUrl()); |
| } |
| mActivity.startActivityForResult(intent, Controller.COMBO_VIEW); |
| } |
| |
| @Override |
| public void showCustomView(View view, int requestedOrientation, |
| CustomViewCallback callback) { |
| // if a view already exists then immediately terminate the new one |
| if (mCustomView != null) { |
| callback.onCustomViewHidden(); |
| return; |
| } |
| |
| mOriginalOrientation = mActivity.getRequestedOrientation(); |
| FrameLayout decor = (FrameLayout) mActivity.getWindow().getDecorView(); |
| mFullscreenContainer = new FullscreenHolder(mActivity); |
| mFullscreenContainer.addView(view, COVER_SCREEN_PARAMS); |
| decor.addView(mFullscreenContainer, COVER_SCREEN_PARAMS); |
| mCustomView = view; |
| setFullscreen(true); |
| ((BrowserWebView) getWebView()).setVisibility(View.INVISIBLE); |
| mCustomViewCallback = callback; |
| mActivity.setRequestedOrientation(requestedOrientation); |
| } |
| |
| @Override |
| public void onHideCustomView() { |
| ((BrowserWebView) getWebView()).setVisibility(View.VISIBLE); |
| if (mCustomView == null) |
| return; |
| setFullscreen(false); |
| FrameLayout decor = (FrameLayout) mActivity.getWindow().getDecorView(); |
| decor.removeView(mFullscreenContainer); |
| mFullscreenContainer = null; |
| mCustomView = null; |
| mCustomViewCallback.onCustomViewHidden(); |
| // Show the content view. |
| mActivity.setRequestedOrientation(mOriginalOrientation); |
| } |
| |
| @Override |
| public boolean isCustomViewShowing() { |
| return mCustomView != null; |
| } |
| |
| protected void dismissIME() { |
| if (mInputManager.isActive()) { |
| mInputManager.hideSoftInputFromWindow(mContentView.getWindowToken(), |
| 0); |
| } |
| } |
| |
| @Override |
| public boolean isWebShowing() { |
| return mCustomView == null; |
| } |
| |
| // ------------------------------------------------------------------------- |
| |
| protected void updateNavigationState(Tab tab) { |
| } |
| |
| /** |
| * Update the lock icon to correspond to our latest state. |
| */ |
| protected void updateLockIconToLatest(Tab t) { |
| if (t != null && t.inForeground()) { |
| updateLockIconImage(t.getSecurityState()); |
| } |
| } |
| |
| /** |
| * Updates the lock-icon image in the title-bar. |
| */ |
| private void updateLockIconImage(SecurityState securityState) { |
| Drawable d = null; |
| if (securityState == SecurityState.SECURITY_STATE_SECURE) { |
| d = mLockIconSecure; |
| } else if (securityState == SecurityState.SECURITY_STATE_MIXED |
| || securityState == SecurityState.SECURITY_STATE_BAD_CERTIFICATE) { |
| // TODO: It would be good to have different icons for insecure vs mixed content. |
| // See http://b/5403800 |
| d = mLockIconMixed; |
| } |
| mNavigationBar.setLock(d); |
| } |
| |
| protected void setUrlTitle(Tab tab) { |
| String url = tab.getUrl(); |
| String title = tab.getTitle(); |
| if (TextUtils.isEmpty(title)) { |
| title = url; |
| } |
| if (tab.inForeground()) { |
| mNavigationBar.setDisplayTitle(url); |
| } |
| } |
| |
| // Set the favicon in the title bar. |
| protected void setFavicon(Tab tab) { |
| if (tab.inForeground()) { |
| Bitmap icon = tab.getFavicon(); |
| mNavigationBar.setFavicon(icon); |
| } |
| } |
| |
| // active tabs page |
| |
| public void showActiveTabsPage() { |
| } |
| |
| /** |
| * Remove the active tabs page. |
| */ |
| public void removeActiveTabsPage() { |
| } |
| |
| // menu handling callbacks |
| |
| @Override |
| public boolean onPrepareOptionsMenu(Menu menu) { |
| return true; |
| } |
| |
| @Override |
| public void updateMenuState(Tab tab, Menu menu) { |
| } |
| |
| @Override |
| public void onOptionsMenuOpened() { |
| } |
| |
| @Override |
| public void onExtendedMenuOpened() { |
| } |
| |
| @Override |
| public boolean onOptionsItemSelected(MenuItem item) { |
| return false; |
| } |
| |
| @Override |
| public void onOptionsMenuClosed(boolean inLoad) { |
| } |
| |
| @Override |
| public void onExtendedMenuClosed(boolean inLoad) { |
| } |
| |
| @Override |
| public void onContextMenuCreated(Menu menu) { |
| } |
| |
| @Override |
| public void onContextMenuClosed(Menu menu, boolean inLoad) { |
| } |
| |
| // error console |
| |
| @Override |
| public void setShouldShowErrorConsole(Tab tab, boolean flag) { |
| if (tab == null) return; |
| ErrorConsoleView errorConsole = tab.getErrorConsole(true); |
| if (flag) { |
| // Setting the show state of the console will cause it's the layout |
| // to be inflated. |
| if (errorConsole.numberOfErrors() > 0) { |
| errorConsole.showConsole(ErrorConsoleView.SHOW_MINIMIZED); |
| } else { |
| errorConsole.showConsole(ErrorConsoleView.SHOW_NONE); |
| } |
| if (errorConsole.getParent() != null) { |
| mErrorConsoleContainer.removeView(errorConsole); |
| } |
| // Now we can add it to the main view. |
| mErrorConsoleContainer.addView(errorConsole, |
| new LinearLayout.LayoutParams( |
| ViewGroup.LayoutParams.MATCH_PARENT, |
| ViewGroup.LayoutParams.WRAP_CONTENT)); |
| } else { |
| mErrorConsoleContainer.removeView(errorConsole); |
| } |
| } |
| |
| // ------------------------------------------------------------------------- |
| // Helper function for WebChromeClient |
| // ------------------------------------------------------------------------- |
| |
| @Override |
| public Bitmap getDefaultVideoPoster() { |
| if (mDefaultVideoPoster == null) { |
| mDefaultVideoPoster = BitmapFactory.decodeResource( |
| mActivity.getResources(), R.drawable.default_video_poster); |
| } |
| return mDefaultVideoPoster; |
| } |
| |
| @Override |
| public View getVideoLoadingProgressView() { |
| if (mVideoProgressView == null) { |
| LayoutInflater inflater = LayoutInflater.from(mActivity); |
| mVideoProgressView = inflater.inflate( |
| R.layout.video_loading_progress, null); |
| } |
| return mVideoProgressView; |
| } |
| |
| @Override |
| public void showMaxTabsWarning() { |
| Toast warning = Toast.makeText(mActivity, |
| mActivity.getString(R.string.max_tabs_warning), |
| Toast.LENGTH_SHORT); |
| warning.show(); |
| } |
| |
| protected WebView getWebView() { |
| if (mActiveTab != null) { |
| return mActiveTab.getWebView(); |
| } else { |
| return null; |
| } |
| } |
| |
| public void setFullscreen(boolean enabled) { |
| Window win = mActivity.getWindow(); |
| WindowManager.LayoutParams winParams = win.getAttributes(); |
| final int bits = WindowManager.LayoutParams.FLAG_FULLSCREEN; |
| if (enabled) { |
| winParams.flags |= bits; |
| } else { |
| winParams.flags &= ~bits; |
| if (mCustomView != null) { |
| mCustomView.setSystemUiVisibility(View.SYSTEM_UI_FLAG_VISIBLE); |
| } else { |
| mContentView.setSystemUiVisibility(View.SYSTEM_UI_FLAG_VISIBLE); |
| } |
| } |
| win.setAttributes(winParams); |
| } |
| |
| public Drawable getFaviconDrawable(Bitmap icon) { |
| Drawable[] array = new Drawable[3]; |
| array[0] = new PaintDrawable(Color.BLACK); |
| PaintDrawable p = new PaintDrawable(Color.WHITE); |
| array[1] = p; |
| if (icon == null) { |
| array[2] = mGenericFavicon; |
| } else { |
| array[2] = new BitmapDrawable(icon); |
| } |
| LayerDrawable d = new LayerDrawable(array); |
| d.setLayerInset(1, 1, 1, 1, 1); |
| d.setLayerInset(2, 2, 2, 2, 2); |
| return d; |
| } |
| |
| public boolean isLoading() { |
| return mActiveTab != null ? mActiveTab.inPageLoad() : false; |
| } |
| |
| /** |
| * Suggest to the UI that the title bar can be hidden. The UI will then |
| * decide whether or not to hide based off a number of factors, such |
| * as if the user is editing the URL bar or if the page is loading |
| */ |
| public void suggestHideTitleBar() { |
| if (!isLoading() && !isEditingUrl() && !mTitleBar.wantsToBeVisible() |
| && !mNavigationBar.isMenuShowing()) { |
| hideTitleBar(); |
| } |
| } |
| |
| protected final void showTitleBarForDuration() { |
| showTitleBarForDuration(HIDE_TITLEBAR_DELAY); |
| } |
| |
| protected final void showTitleBarForDuration(long duration) { |
| showTitleBar(); |
| Message msg = Message.obtain(mHandler, MSG_HIDE_TITLEBAR); |
| mHandler.sendMessageDelayed(msg, duration); |
| } |
| |
| protected Handler mHandler = new Handler() { |
| |
| @Override |
| public void handleMessage(Message msg) { |
| if (msg.what == MSG_HIDE_TITLEBAR) { |
| suggestHideTitleBar(); |
| } |
| BaseUi.this.handleMessage(msg); |
| } |
| }; |
| |
| protected void handleMessage(Message msg) {} |
| |
| @Override |
| public void showWeb(boolean animate) { |
| mUiController.hideCustomView(); |
| } |
| |
| static class FullscreenHolder extends FrameLayout { |
| |
| public FullscreenHolder(Context ctx) { |
| super(ctx); |
| setBackgroundColor(ctx.getResources().getColor(R.color.black)); |
| } |
| |
| @Override |
| public boolean onTouchEvent(MotionEvent evt) { |
| return true; |
| } |
| |
| } |
| |
| public void addFixedTitleBar(View view) { |
| mFixedTitlebarContainer.addView(view); |
| } |
| |
| public void setContentViewMarginTop(int margin) { |
| LinearLayout.LayoutParams params = |
| (LinearLayout.LayoutParams) mContentView.getLayoutParams(); |
| if (params.topMargin != margin) { |
| params.topMargin = margin; |
| mContentView.setLayoutParams(params); |
| } |
| } |
| |
| @Override |
| public boolean blockFocusAnimations() { |
| return mBlockFocusAnimations; |
| } |
| |
| @Override |
| public void onVoiceResult(String result) { |
| mNavigationBar.onVoiceResult(result); |
| } |
| |
| protected UiController getUiController() { |
| return mUiController; |
| } |
| |
| @Override |
| public void onActionModeStarted(ActionMode mode) { |
| int fixedTbarHeight = mTitleBar.isFixed() ? mTitleBar.calculateEmbeddedHeight() : 0; |
| mFixedTitlebarContainer.setY(fixedTbarHeight); |
| setContentViewMarginTop(fixedTbarHeight); |
| } |
| |
| @Override |
| public void onActionModeFinished(boolean inLoad) { |
| mFixedTitlebarContainer.setY(0); |
| setContentViewMarginTop(0); |
| } |
| } |