예제 #1
0
  @Override
  public void onTabOrModelChanged() {
    super.onTabOrModelChanged();
    boolean incognito = isIncognito();
    if (mUseLightColorAssets == null || mUseLightColorAssets != incognito) {
      setBackgroundResource(
          incognito ? R.color.incognito_primary_color : R.color.default_primary_color);

      mMenuButton.setTint(incognito ? mLightModeTint : mDarkModeTint);
      mHomeButton.setTint(incognito ? mLightModeTint : mDarkModeTint);
      mBackButton.setTint(incognito ? mLightModeTint : mDarkModeTint);
      mForwardButton.setTint(incognito ? mLightModeTint : mDarkModeTint);
      if (incognito) {
        mLocationBar
            .getContainerView()
            .getBackground()
            .setAlpha(ToolbarPhone.LOCATION_BAR_TRANSPARENT_BACKGROUND_ALPHA);
      } else {
        mLocationBar.getContainerView().getBackground().setAlpha(255);
      }
      mAccessibilitySwitcherButton.setImageDrawable(
          incognito ? mTabSwitcherButtonDrawableLight : mTabSwitcherButtonDrawable);
      mLocationBar.updateVisualsForState();
      if (mShowMenuBadge) {
        setAppMenuUpdateBadgeDrawable(incognito);
      }
      mUseLightColorAssets = incognito;
    }
    mLocationBar.setUrlBarFocus(false);
  }
예제 #2
0
 /**
  * Sets the handler for any special case handling related with the menu button.
  *
  * @param menuHandler The handler to be used.
  */
 private void setMenuHandler(AppMenuHandler menuHandler) {
   menuHandler.addObserver(
       new AppMenuObserver() {
         @Override
         public void onMenuVisibilityChanged(boolean isVisible) {
           if (mFullscreenManager == null) return;
           if (isVisible) {
             mFullscreenMenuToken =
                 mFullscreenManager.showControlsPersistentAndClearOldToken(mFullscreenMenuToken);
           } else {
             mFullscreenManager.hideControlsPersistent(mFullscreenMenuToken);
             mFullscreenMenuToken = FullscreenManager.INVALID_TOKEN;
           }
         }
       });
   mAppMenuButtonHelper = new AppMenuButtonHelper(menuHandler);
   mAppMenuButtonHelper.setOnAppMenuShownListener(
       new Runnable() {
         @Override
         public void run() {
           RecordUserAction.record("MobileToolbarShowMenu");
         }
       });
   mLocationBar.setMenuButtonHelper(mAppMenuButtonHelper);
 }
예제 #3
0
 @Override
 protected void setTabSwitcherMode(
     boolean inTabSwitcherMode, boolean showToolbar, boolean delayAnimation) {
   if (mShowTabStack && inTabSwitcherMode) {
     mIsInTabSwitcherMode = true;
     mBackButton.setEnabled(false);
     mForwardButton.setEnabled(false);
     mReloadButton.setEnabled(false);
     mLocationBar.getContainerView().setVisibility(View.INVISIBLE);
     if (mShowMenuBadge) {
       mMenuBadge.setVisibility(View.GONE);
     }
   } else {
     mIsInTabSwitcherMode = false;
     mLocationBar.getContainerView().setVisibility(View.VISIBLE);
     if (mShowMenuBadge) {
       setAppMenuUpdateBadgeToVisible(false);
     }
   }
 }
예제 #4
0
  /** Triggered when the selected tab has changed. */
  private void refreshSelectedTab() {
    ChromeTab tab = null;
    if (mPreselectedTabId != Tab.INVALID_TAB_ID) {
      tab = ChromeTab.fromTab(mTabModelSelector.getTabById(mPreselectedTabId));
    }
    if (tab == null) tab = ChromeTab.fromTab(mTabModelSelector.getCurrentTab());

    boolean wasIncognito = mToolbarModel.isIncognito();
    ChromeTab previousTab = ChromeTab.fromTab(mToolbarModel.getTab());

    boolean isIncognito = tab != null ? tab.isIncognito() : mTabModelSelector.isIncognitoSelected();
    mToolbarModel.setTab(tab, isIncognito);

    updateCurrentTabDisplayStatus();
    if (previousTab != tab || wasIncognito != isIncognito) {
      if (previousTab != tab) {
        if (previousTab != null) previousTab.removeObserver(mTabObserver);
        if (tab != null) tab.addObserver(mTabObserver);
      }
      int defaultPrimaryColor =
          isIncognito
              ? mToolbar.getResources().getColor(R.color.incognito_primary_color)
              : mToolbar.getResources().getColor(R.color.default_primary_color);
      int primaryColor =
          (tab != null && tab.getWebContents() != null)
              ? tab.getWebContents().getThemeColor(defaultPrimaryColor)
              : defaultPrimaryColor;
      updatePrimaryColor(primaryColor);

      mToolbar.onTabOrModelChanged();

      if (tab != null
          && tab.getWebContents() != null
          && tab.getWebContents().isLoadingToDifferentDocument()) {
        mToolbar.onNavigatedToDifferentPage();
      }
    }

    Profile profile = mTabModelSelector.getModel(isIncognito).getProfile();
    if (mCurrentProfile != profile) {
      if (mBookmarksBridge != null) mBookmarksBridge.destroy();
      mBookmarksBridge = new BookmarksBridge(profile);
      mBookmarksBridge.addObserver(mBookmarksObserver);
      mLocationBar.setAutocompleteProfile(profile);
      mCurrentProfile = profile;
    }
  }
예제 #5
0
  private void updateCurrentTabDisplayStatus() {
    Tab currentTab = mToolbarModel.getTab();
    mLocationBar.setUrlToPageUrl();
    if (currentTab == null) {
      updateLoadProgressInternal(0);
      updateButtonStatus();
      return;
    }
    boolean isLoading = currentTab.isLoading();
    updateTabLoadingState(isLoading, true);

    if (currentTab.getProgress() == 100 || currentTab.isShowingInterstitialPage()) {
      // We are switching to a tab that is fully loaded. Don't set the load progress to 1.0,
      // that would cause the load progress bar to show briefly.
      updateLoadProgressInternal(0);
    } else {
      updateLoadProgress(currentTab.getProgress());
    }
    updateButtonStatus();
  }
예제 #6
0
 /**
  * Sets whether a title should be shown within the Toolbar.
  *
  * @param showTitle Whether a title should be shown.
  */
 public void setShowTitle(boolean showTitle) {
   mLocationBar.setShowTitle(showTitle);
 }
예제 #7
0
  /**
   * Creates a ToolbarManager object.
   *
   * @param controlContainer The container of the toolbar.
   * @param menuHandler The handler for interacting with the menu.
   */
  public ToolbarManager(
      final ChromeActivity activity,
      ToolbarControlContainer controlContainer,
      final AppMenuHandler menuHandler,
      final ChromeAppMenuPropertiesDelegate appMenuPropertiesDelegate,
      Invalidator invalidator) {
    mActionBarDelegate =
        new ContextualMenuBar.ActionBarDelegate() {
          @Override
          public void setControlTopMargin(int margin) {
            FrameLayout.LayoutParams lp =
                (FrameLayout.LayoutParams) mControlContainer.getLayoutParams();
            lp.topMargin = margin;
            mControlContainer.setLayoutParams(lp);
          }

          @Override
          public int getControlTopMargin() {
            FrameLayout.LayoutParams lp =
                (FrameLayout.LayoutParams) mControlContainer.getLayoutParams();
            return lp.topMargin;
          }

          @Override
          public ActionBar getSupportActionBar() {
            return activity.getSupportActionBar();
          }

          @Override
          public void setActionBarBackgroundVisibility(boolean visible) {
            int visibility = visible ? View.VISIBLE : View.GONE;
            activity.findViewById(R.id.action_bar_black_background).setVisibility(visibility);
            // TODO(tedchoc): Add support for changing the color based on the brand color.
          }
        };

    mToolbarModel = new ToolbarModelImpl();
    mControlContainer = controlContainer;
    assert mControlContainer != null;

    mToolbar = (ToolbarLayout) controlContainer.findViewById(R.id.toolbar);

    mToolbar.setPaintInvalidator(invalidator);

    mContextualMenuBar = new ContextualMenuBar(activity, mActionBarDelegate);
    mContextualMenuBar.setCustomSelectionActionModeCallback(
        new CustomSelectionActionModeCallback());
    mContextualMenuBar.setTabStripHeight(mToolbar.getTabStripHeight());

    MenuDelegatePhone menuDelegate =
        new MenuDelegatePhone() {
          @Override
          public void updateReloadButtonState(boolean isLoading) {
            if (appMenuPropertiesDelegate != null) {
              appMenuPropertiesDelegate.loadingStateChanged(isLoading);
              menuHandler.menuItemContentChanged(R.id.icon_row_menu_id);
            }
          }
        };
    setMenuDelegatePhone(menuDelegate);

    mLocationBar = mToolbar.getLocationBar();
    mLocationBar.setToolbarDataProvider(mToolbarModel);
    mLocationBar.setUrlFocusChangeListener(this);
    mLocationBar.setDefaultTextEditActionModeCallback(
        mContextualMenuBar.getCustomSelectionActionModeCallback());
    mLocationBar.initializeControls(
        new WindowDelegate(activity.getWindow()),
        mContextualMenuBar.getActionBarDelegate(),
        activity.getWindowAndroid());
    mLocationBar.setIgnoreURLBarModification(false);

    setMenuHandler(menuHandler);
    mToolbar.initialize(mToolbarModel, this, mAppMenuButtonHelper);

    mHomepageStateListener =
        new HomepageStateListener() {
          @Override
          public void onHomepageStateUpdated() {
            mToolbar.onHomeButtonUpdate(HomepageManager.isHomepageEnabled(mToolbar.getContext()));
          }
        };
    HomepageManager.getInstance(mToolbar.getContext()).addListener(mHomepageStateListener);

    mTabModelSelectorObserver =
        new EmptyTabModelSelectorObserver() {
          @Override
          public void onTabModelSelected(TabModel newModel, TabModel oldModel) {
            refreshSelectedTab();
            updateTabCount();
            mControlContainer.invalidateBitmap();
          }

          @Override
          public void onTabStateInitialized() {
            mTabRestoreCompleted = true;
            handleTabRestoreCompleted();
          }
        };

    mTabModelObserver =
        new EmptyTabModelObserver() {
          @Override
          public void didAddTab(Tab tab, TabLaunchType type) {
            updateTabCount();
          }

          @Override
          public void didSelectTab(Tab tab, TabSelectionType type, int lastId) {
            mPreselectedTabId = Tab.INVALID_TAB_ID;
            refreshSelectedTab();
          }

          @Override
          public void tabClosureUndone(Tab tab) {
            updateTabCount();
            refreshSelectedTab();
          }

          @Override
          public void didCloseTab(Tab tab) {
            updateTabCount();
            refreshSelectedTab();
          }

          @Override
          public void tabPendingClosure(Tab tab) {
            updateTabCount();
            refreshSelectedTab();
          }

          @Override
          public void allTabsPendingClosure(List<Integer> tabIds) {
            updateTabCount();
            refreshSelectedTab();
          }
        };

    mTabObserver =
        new EmptyTabObserver() {
          @Override
          public void onSSLStateUpdated(Tab tab) {
            super.onSSLStateUpdated(tab);
            assert tab == mToolbarModel.getTab();
            mLocationBar.updateSecurityIcon(tab.getSecurityLevel());
          }

          @Override
          public void onWebContentsInstantSupportDisabled() {
            mLocationBar.setUrlToPageUrl();
          }

          @Override
          public void onDidNavigateMainFrame(
              Tab tab,
              String url,
              String baseUrl,
              boolean isNavigationToDifferentPage,
              boolean isFragmentNavigation,
              int statusCode) {
            if (isNavigationToDifferentPage) {
              mToolbar.onNavigatedToDifferentPage();
            }
          }

          @Override
          public void onPageLoadStarted(Tab tab, String url) {
            updateButtonStatus();
            updateTabLoadingState(true, true);
          }

          @Override
          public void onPageLoadFinished(Tab tab) {
            ToolbarManager.this.onPageLoadFinished();
          }

          @Override
          public void onPageLoadFailed(Tab tab, int errorCode) {
            ToolbarManager.this.onPageLoadFailed();
          }

          @Override
          public void onTitleUpdated(Tab tab) {
            mLocationBar.setTitleToPageTitle();
          }

          @Override
          public void onUrlUpdated(Tab tab) {
            // Update the SSL security state as a result of this notification as it will
            // sometimes be the only update we receive.
            updateTabLoadingState(false, true);

            // A URL update is a decent enough indicator that the toolbar widget is in
            // a stable state to capture its bitmap for use in fullscreen.
            mControlContainer.setReadyForBitmapCapture(true);
          }

          @Override
          public void onCrash(Tab tab, boolean sadTabShown) {
            onTabCrash();
          }

          @Override
          public void onLoadProgressChanged(Tab tab, int progress) {
            updateLoadProgress(progress);
          }

          @Override
          public void onContentChanged(Tab tab) {
            mToolbar.onTabContentViewChanged();
          }

          @Override
          public void onWebContentsSwapped(Tab tab, boolean didStartLoad, boolean didFinishLoad) {
            if (!didStartLoad) return;

            ChromeTab chromeTab = ChromeTab.fromTab(tab);
            if (!chromeTab.getBackgroundContentViewHelper().isPageSwappingInProgress()
                && didFinishLoad) {
              mLoadProgressSimulator.start();
            }
          }

          @Override
          public void onDidStartNavigationToPendingEntry(Tab tab, String url) {
            // Update URL as soon as it becomes available when it's a new tab.
            // But we want to update only when it's a new tab. So we check whether the current
            // navigation entry is initial, meaning whether it has the same target URL as the
            // initial URL of the tab.
            WebContents webContents = tab.getWebContents();
            if (webContents == null) return;
            NavigationController navigationController = webContents.getNavigationController();
            if (navigationController == null) return;
            if (navigationController.isInitialNavigation()) {
              mLocationBar.setUrlToPageUrl();
            }
          }

          @Override
          public void onLoadUrl(Tab tab, LoadUrlParams params, int loadType) {
            NewTabPage ntp = mToolbarModel.getNewTabPageForCurrentTab();
            if (ntp == null) return;
            if (!NewTabPage.isNTPUrl(params.getUrl())
                && loadType != TabLoadStatus.PAGE_LOAD_FAILED) {
              ntp.setUrlFocusAnimationsDisabled(true);
              mToolbar.onTabOrModelChanged();
            }
          }

          @Override
          public void onDidFailLoad(
              Tab tab,
              boolean isProvisionalLoad,
              boolean isMainFrame,
              int errorCode,
              String description,
              String failingUrl) {
            NewTabPage ntp = mToolbarModel.getNewTabPageForCurrentTab();
            if (ntp == null) return;
            if (isProvisionalLoad && isMainFrame) {
              ntp.setUrlFocusAnimationsDisabled(false);
              mToolbar.onTabOrModelChanged();
            }
          }

          @Override
          public void onContextualActionBarVisibilityChanged(Tab tab, boolean visible) {
            if (visible) RecordUserAction.record("MobileActionBarShown");
            ActionBar actionBar = mActionBarDelegate.getSupportActionBar();
            if (!visible && actionBar != null) actionBar.hide();
            if (DeviceFormFactor.isTablet(activity)) {
              if (visible) {
                mContextualMenuBar.showControls();
              } else {
                mContextualMenuBar.hideControls();
              }
            }
          }
        };

    mBookmarksObserver =
        new BookmarksBridge.BookmarkModelObserver() {
          @Override
          public void bookmarkModelChanged() {
            updateBookmarkButtonStatus();
          }
        };

    mFindToolbarObserver =
        new FindToolbarObserver() {
          @Override
          public void onFindToolbarShown() {
            mToolbar.handleFindToolbarStateChange(true);
            if (mFullscreenManager != null) {
              mFullscreenFindInPageToken =
                  mFullscreenManager.showControlsPersistentAndClearOldToken(
                      mFullscreenFindInPageToken);
            }
          }

          @Override
          public void onFindToolbarHidden() {
            mToolbar.handleFindToolbarStateChange(false);
            if (mFullscreenManager != null) {
              mFullscreenManager.hideControlsPersistent(mFullscreenFindInPageToken);
              mFullscreenFindInPageToken = FullscreenManager.INVALID_TOKEN;
            }
          }
        };

    mOverviewModeObserver =
        new EmptyOverviewModeObserver() {
          @Override
          public void onOverviewModeStartedShowing(boolean showToolbar) {
            mToolbar.setTabSwitcherMode(true, showToolbar, false);
            updateButtonStatus();
          }

          @Override
          public void onOverviewModeStartedHiding(boolean showToolbar, boolean delayAnimation) {
            mToolbar.setTabSwitcherMode(false, showToolbar, delayAnimation);
            updateButtonStatus();
          }

          @Override
          public void onOverviewModeFinishedHiding() {
            mToolbar.onTabSwitcherTransitionFinished();
          }
        };

    mSceneChangeObserver =
        new SceneChangeObserver() {
          @Override
          public void onTabSelectionHinted(int tabId) {
            mPreselectedTabId = tabId;
            refreshSelectedTab();
          }

          @Override
          public void onSceneChange(Layout layout) {
            mToolbar.setContentAttached(layout.shouldDisplayContentOverlay());
          }
        };

    mLoadProgressSimulator = new LoadProgressSimulator(this);
  }
예제 #8
0
 private void updateTabLoadingState(boolean isLoading, boolean updateUrl) {
   Tab currentTab = mToolbarModel.getTab();
   mLocationBar.updateLoadingState(updateUrl);
   if (isLoading) updateLoadProgress(currentTab.getProgress());
   if (updateUrl) updateButtonStatus();
 }
예제 #9
0
  /**
   * Sets up key listeners after native initialization is complete, so that we can invoke native
   * functions.
   */
  @Override
  public void onNativeLibraryReady() {
    super.onNativeLibraryReady();
    mLocationBar.onNativeLibraryReady();
    mHomeButton.setOnClickListener(this);
    mHomeButton.setOnKeyListener(
        new KeyboardNavigationListener() {
          @Override
          public View getNextFocusForward() {
            if (mBackButton.isFocusable()) {
              return findViewById(R.id.back_button);
            } else if (mForwardButton.isFocusable()) {
              return findViewById(R.id.forward_button);
            } else {
              return findViewById(R.id.refresh_button);
            }
          }

          @Override
          public View getNextFocusBackward() {
            return findViewById(R.id.menu_button);
          }
        });

    mBackButton.setOnClickListener(this);
    mBackButton.setLongClickable(true);
    mBackButton.setOnKeyListener(
        new KeyboardNavigationListener() {
          @Override
          public View getNextFocusForward() {
            if (mForwardButton.isFocusable()) {
              return findViewById(R.id.forward_button);
            } else {
              return findViewById(R.id.refresh_button);
            }
          }

          @Override
          public View getNextFocusBackward() {
            if (mHomeButton.getVisibility() == VISIBLE) {
              return findViewById(R.id.home_button);
            } else {
              return findViewById(R.id.menu_button);
            }
          }
        });

    mForwardButton.setOnClickListener(this);
    mForwardButton.setLongClickable(true);
    mForwardButton.setOnKeyListener(
        new KeyboardNavigationListener() {
          @Override
          public View getNextFocusForward() {
            return findViewById(R.id.refresh_button);
          }

          @Override
          public View getNextFocusBackward() {
            if (mBackButton.isFocusable()) {
              return mBackButton;
            } else if (mHomeButton.getVisibility() == VISIBLE) {
              return findViewById(R.id.home_button);
            } else {
              return findViewById(R.id.menu_button);
            }
          }
        });

    mReloadButton.setOnClickListener(this);
    mReloadButton.setOnKeyListener(
        new KeyboardNavigationListener() {
          @Override
          public View getNextFocusForward() {
            return findViewById(R.id.url_bar);
          }

          @Override
          public View getNextFocusBackward() {
            if (mForwardButton.isFocusable()) {
              return mForwardButton;
            } else if (mBackButton.isFocusable()) {
              return mBackButton;
            } else if (mHomeButton.getVisibility() == VISIBLE) {
              return findViewById(R.id.home_button);
            } else {
              return findViewById(R.id.menu_button);
            }
          }
        });

    mAccessibilitySwitcherButton.setOnClickListener(this);
    mBookmarkButton.setOnClickListener(this);

    mMenuButton.setOnKeyListener(
        new KeyboardNavigationListener() {
          @Override
          public View getNextFocusForward() {
            return getCurrentTabView();
          }

          @Override
          public View getNextFocusBackward() {
            return findViewById(R.id.url_bar);
          }

          @Override
          protected boolean handleEnterKeyPress() {
            return getMenuButtonHelper().onEnterKeyPress(mMenuButton);
          }
        });
    if (HomepageManager.isHomepageEnabled(getContext())) {
      mHomeButton.setVisibility(VISIBLE);
    }
  }