揭秘uc浏览器二

这节，四个议题：

①一个网页显示在webview控件中

②如何正常隐藏显示标题栏。

③如何用runnable来隐藏标题栏，这样子就更加的专业化。

④上节我们说道了QuickActionGrid，看他长得怎么样。

如何显示webview控件了，This is a question?这个除了上面的文章的支持外，主要是这个updateUI的方法。

/**
     * Update the UI: Url edit text, previous/next button state,...
     */
    private void updateUI() {
        mUrlEditText.removeTextChangedListener(mUrlTextWatcher);
        mUrlEditText.setText(mCurrentWebView.getUrl());
        mUrlEditText.addTextChangedListener(mUrlTextWatcher);
        
        mPreviousButton.setEnabled(mCurrentWebView.canGoBack());
        mNextButton.setEnabled(mCurrentWebView.canGoForward());
        
        if (mCurrentWebView.getUrl() != null)
            mRemoveTabButton.setEnabled((mViewFlipper.getChildCount() > 1 || !mCurrentWebView.getUrl().equals(Constants.URL_ABOUT_START)));
        else
            mRemoveTabButton.setEnabled(mViewFlipper.getChildCount() > 1);
        
        mProgressBar.setProgress(mCurrentWebView.getProgress());
        
        updateGoButton();
        
        updateTitle();
        
        updateFavIcon();
    }
    

这段代码是如此的熟悉，我们也来总结总结：

①我们需要更新URL文本框的数据，添加新的事件的监听。

②把前一步，后一步按钮设置是否禁用。

③把移去按钮，设置是否禁用。

④把进度条进度进行更新。

⑤更新去哪儿的按钮

⑥更新相应的标题

⑦更新相应的图标

这个webview视图进行显示了，相应视图也进行更新了。

如何正常显示标题栏，这个就是updateTitle方法做的事情，来瞧一瞧：

    /**
     * Update the application title.
     */
    private void updateTitle() {
        String value = mCurrentWebView.getTitle();
        
        if ((value != null) &&
                (value.length() > 0)) {        
            this.setTitle(String.format(getResources().getString(R.string.ApplicationNameUrl), value));            
        } else {
            clearTitle();
        }
    }

这是一个更新标题的方法，我们可以得出来相应总结，

①我们可以获取当前webview的标题，如果是标题不为空的话，我们就设置相应的标题。否则就清空标题.

正常的隐藏标题栏，极大提高了用户体验，这是一个runnable接口功劳，那具体怎么做了：

/**
     * Start a runnable to hide the tool bars after a user-defined delay.
     */
    private void startToolbarsHideRunnable() {
                        
        if (mHideToolbarsRunnable != null) {
            mHideToolbarsRunnable.setDisabled();
        }
        
        int delay = Integer.parseInt(Controller.getInstance().getPreferences().getString(Constants.PREFERENCES_GENERAL_BARS_DURATION, "3000"));
        if (delay <= 0) {
            delay = 3000;
        }
        
        mHideToolbarsRunnable = new HideToolbarsRunnable(this, delay);        
        new Thread(mHideToolbarsRunnable).start();
    }
    
    /**
     * Hide the tool bars.
     */
    public void hideToolbars() {
        if (mUrlBarVisible) {            
            if ((!mUrlEditText.hasFocus()) &&
                    (!mToolsActionGridVisible)) {
                
                if (!mCurrentWebView.isLoading()) {
                    setToolbarsVisibility(false);
                }
            }
        }
        mHideToolbarsRunnable = null;
    }

我这里能够得到这样的提示了：

①用到sharedpreference看用户设置时间，如果没有设置时间的话，默认是3秒就开启一条线程将其标题栏隐藏了。为什么会用到多线程了，这样不会更新主界面造成卡顿的现象。

②如果toolbar是隐藏的，就将其隐藏。

QuickActionGrid是一个自定义控件，为什么用自定义控件了，

①android自带的控件太多bug。

②自定义控件也非常的灵活。

源代码如下：

public class QuickActionGrid extends QuickActionWidget {

//    grid 控件
    private GridView mGridView;

    /**
     * grid 构造函数  数据的初始化
     * @param context  上下文对象
     */
    public QuickActionGrid(Context context) {
        super(context);

        setContentView(R.layout.gd_quick_action_grid);

        final View v = getContentView();
        mGridView = (GridView) v.findViewById(R.id.gdi_grid);
    }
    /**
     * 弹出相应的action的方法
     */

    @Override
    protected void populateQuickActions(final List<QuickAction> quickActions) {

        mGridView.setAdapter(new BaseAdapter() {

            public View getView(int position, View view, ViewGroup parent) {

                TextView textView = (TextView) view;

                if (view == null) {
                    final LayoutInflater inflater = LayoutInflater.from(getContext());
                    textView = (TextView) inflater.inflate(R.layout.gd_quick_action_grid_item, mGridView, false);
                }

                QuickAction quickAction = quickActions.get(position);
                textView.setText(quickAction.mTitle);
                textView.setCompoundDrawablesWithIntrinsicBounds(null, quickAction.mDrawable, null, null);

                return textView;

            }

            public long getItemId(int position) {
                return position;
            }

            public Object getItem(int position) {
                return null;
            }

            public int getCount() {
                return quickActions.size();
            }
        });

        mGridView.setOnItemClickListener(mInternalItemClickListener);
    }

    /**
     * 尺寸改变的事件
     */
    @Override
    protected void onMeasureAndLayout(Rect anchorRect, View contentView) {

        contentView.setLayoutParams(new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT));
        contentView.measure(MeasureSpec.makeMeasureSpec(getScreenWidth(), MeasureSpec.EXACTLY),
                LayoutParams.WRAP_CONTENT);

        int rootHeight = contentView.getMeasuredHeight();

        int offsetY = getArrowOffsetY();
        int dyTop = anchorRect.top;
        int dyBottom = getScreenHeight() - anchorRect.bottom;

        boolean onTop = (dyTop > dyBottom);
        int popupY = (onTop) ? anchorRect.top - rootHeight + offsetY : anchorRect.bottom - offsetY;

        setWidgetSpecs(popupY, onTop);
    }

    /**
     * 每项点击的事件
     */
    private OnItemClickListener mInternalItemClickListener = new OnItemClickListener() {
        public void onItemClick(AdapterView<?> adapterView, View view, int position, long id) {
            getOnQuickActionClickListener().onQuickActionClicked(QuickActionGrid.this, position);
            if (getDismissOnClick()) {
                dismiss();
            }
        }
    };

}

这个quickGrid控件是继承与quickWidget控件，这也是一个自定义控件。对于他这个方法，我们集中于populateQuickActions方法和onMeasureAndLayout方法。

①populateQuickActions方法其实就是一个填充相应数据的方法，就是把相应的数据通过baseAdapter填充与gridview控件，gridview控件用于显示相应数据项。

②mInternalItemClickListener方法了，就是为每一个item赋予点击事件，如果这个点击动作已经执行以后，就相应弹出的popwindow就进行了隐藏。

quickwidget控件在这个项目用的很多，这是许多控件的基类，怎么写的。

    private static final int MEASURE_AND_LAYOUT_DONE = 1 << 1;

    private final int[] mLocation = new int[2];
    private final Rect mRect = new Rect();

    private int mPrivateFlags;

    private Context mContext;

    private boolean mDismissOnClick;
    private int mArrowOffsetY;

    private int mPopupY;
    private boolean mIsOnTop;

    private int mScreenHeight;
    private int mScreenWidth;
    private boolean mIsDirty;

    private OnQuickActionClickListener mOnQuickActionClickListener;
    private ArrayList<QuickAction> mQuickActions = new ArrayList<QuickAction>();

    /**
     * Interface that may be used to listen to clicks on quick actions.
     *
     * @author Benjamin Fellous
     * @author Cyril Mottier
     */
    public static interface OnQuickActionClickListener {
        /**
         * Clients may implement this method to be notified of a click on a
         * particular quick action.
         *
         * @param position Position of the quick action that have been clicked.
         */
        void onQuickActionClicked(QuickActionWidget widget, int position);
    }

    /**
     * Creates a new QuickActionWidget for the given context.
     *
     * @param context The context in which the QuickActionWidget is running in
     */
    public QuickActionWidget(Context context) {
        super(context);

        mContext = context;

        initializeDefault();

        setFocusable(true);
        setTouchable(true);
        setOutsideTouchable(true);
        setWidth(WindowManager.LayoutParams.WRAP_CONTENT);
        setHeight(WindowManager.LayoutParams.WRAP_CONTENT);

        final WindowManager windowManager = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
        mScreenWidth = windowManager.getDefaultDisplay().getWidth();
        mScreenHeight = windowManager.getDefaultDisplay().getHeight();
    }

    /**
     * Equivalent to {@link PopupWindow#setContentView(View)} but with a layout
     * identifier.
     *
     * @param layoutId The layout identifier of the view to use.
     */
    public void setContentView(int layoutId) {
        setContentView(LayoutInflater.from(mContext).inflate(layoutId, null));
    }

    private void initializeDefault() {
        mDismissOnClick = true;
        mArrowOffsetY = mContext.getResources().getDimensionPixelSize(R.dimen.gd_arrow_offset);
    }

    /**
     * Returns the arrow offset for the Y axis.
     *
     * @see {@link #setArrowOffsetY(int)}
     * @return The arrow offset.
     */
    public int getArrowOffsetY() {
        return mArrowOffsetY;
    }

    /**
     * Sets the arrow offset to a new value. Setting an arrow offset may be
     * particular useful to warn which view the QuickActionWidget is related to.
     * By setting a positive offset, the arrow will overlap the view given by
     * {@link #show(View)}. The default value is 5dp.
     *
     * @param offsetY The offset for the Y axis
     */
    public void setArrowOffsetY(int offsetY) {
        mArrowOffsetY = offsetY;
    }

    /**
     * Returns the width of the screen.
     *
     * @return The width of the screen
     */
    protected int getScreenWidth() {
        return mScreenWidth;
    }

    /**
     * Returns the height of the screen.
     *
     * @return The height of the screen
     */
    protected int getScreenHeight() {
        return mScreenHeight;
    }

    /**
     * By default, a {@link QuickActionWidget} is dismissed once the user
     * clicked on a {@link QuickAction}. This behavior can be changed using this
     * method.
     *
     * @param dismissOnClick True if you want the {@link QuickActionWidget} to
     * be dismissed on click else false.
     */
    public void setDismissOnClick(boolean dismissOnClick) {
        mDismissOnClick = dismissOnClick;
    }

    public boolean getDismissOnClick() {
        return mDismissOnClick;
    }

    /**
     * @param listener
     */
    public void setOnQuickActionClickListener(OnQuickActionClickListener listener) {
        mOnQuickActionClickListener = listener;
    }

    /**
     * Add a new QuickAction to this {@link QuickActionWidget}. Adding a new
     * {@link QuickAction} while the {@link QuickActionWidget} is currently
     * being shown does nothing. The new {@link QuickAction} will be displayed
     * on the next call to {@link #show(View)}.
     *
     * @param action The new {@link QuickAction} to add
     */
    public void addQuickAction(QuickAction action) {
        if (action != null) {
            mQuickActions.add(action);
            mIsDirty = true;
        }
    }

    /**
     * Removes all {@link QuickAction} from this {@link QuickActionWidget}.
     */
    public void clearAllQuickActions() {
        if (!mQuickActions.isEmpty()) {
            mQuickActions.clear();
            mIsDirty = true;
        }
    }

    /**
     * Call that method to display the {@link QuickActionWidget} anchored to the
     * given view.
     *
     * @param anchor The view the {@link QuickActionWidget} will be anchored to.
     */
    public void show(View anchor) {

        final View contentView = getContentView();

        if (contentView == null) {
            throw new IllegalStateException("You need to set the content view using the setContentView method");
        }

        // Replaces the background of the popup with a cleared background
        setBackgroundDrawable(new ColorDrawable(Color.TRANSPARENT));

        final int[] loc = mLocation;
        anchor.getLocationOnScreen(loc);
        mRect.set(loc[0], loc[1], loc[0] + anchor.getWidth(), loc[1] + anchor.getHeight());

        if (mIsDirty) {
            clearQuickActions();
            populateQuickActions(mQuickActions);
        }

        onMeasureAndLayout(mRect, contentView);

        if ((mPrivateFlags & MEASURE_AND_LAYOUT_DONE) != MEASURE_AND_LAYOUT_DONE) {
            throw new IllegalStateException("onMeasureAndLayout() did not set the widget specification by calling"
                    + " setWidgetSpecs()");
        }

        showArrow();
        prepareAnimationStyle();
        showAtLocation(anchor, Gravity.NO_GRAVITY, 0, mPopupY);
    }

    protected void clearQuickActions() {
        if (!mQuickActions.isEmpty()) {
            onClearQuickActions();
        }
    }

    protected void onClearQuickActions() {
    }

    protected abstract void populateQuickActions(List<QuickAction> quickActions);

    protected abstract void onMeasureAndLayout(Rect anchorRect, View contentView);

    protected void setWidgetSpecs(int popupY, boolean isOnTop) {
        mPopupY = popupY;
        mIsOnTop = isOnTop;

        mPrivateFlags |= MEASURE_AND_LAYOUT_DONE;
    }

    private void showArrow() {

        final View contentView = getContentView();
        final int arrowId = mIsOnTop ? R.id.gdi_arrow_down : R.id.gdi_arrow_up;
        final View arrow = contentView.findViewById(arrowId);
        final View arrowUp = contentView.findViewById(R.id.gdi_arrow_up);
        final View arrowDown = contentView.findViewById(R.id.gdi_arrow_down);

        if (arrowId == R.id.gdi_arrow_up) {
            arrowUp.setVisibility(View.VISIBLE);
            arrowDown.setVisibility(View.INVISIBLE);
        } else if (arrowId == R.id.gdi_arrow_down) {
            arrowUp.setVisibility(View.INVISIBLE);
            arrowDown.setVisibility(View.VISIBLE);
        }

        ViewGroup.MarginLayoutParams param = (ViewGroup.MarginLayoutParams) arrow.getLayoutParams();
        param.leftMargin = mRect.centerX() - (arrow.getMeasuredWidth()) / 2;
    }

    private void prepareAnimationStyle() {

        final int screenWidth = mScreenWidth;
        final boolean onTop = mIsOnTop;
        final int arrowPointX = mRect.centerX();

        if (arrowPointX <= screenWidth / 4) {
            setAnimationStyle(onTop ? R.style.GreenDroid_Animation_PopUp_Left
                    : R.style.GreenDroid_Animation_PopDown_Left);
        } else if (arrowPointX >= 3 * screenWidth / 4) {
            setAnimationStyle(onTop ? R.style.GreenDroid_Animation_PopUp_Right
                    : R.style.GreenDroid_Animation_PopDown_Right);
        } else {
            setAnimationStyle(onTop ? R.style.GreenDroid_Animation_PopUp_Center
                    : R.style.GreenDroid_Animation_PopDown_Center);
        }
    }

    protected Context getContext() {
        return mContext;
    }

    protected OnQuickActionClickListener getOnQuickActionClickListener() {
        return mOnQuickActionClickListener;
    }

首先这个控件本质是Popwindow，对于这个控件我们要探讨的有这么几点：

①show这个方法中了，主要是根据相应的锚基点来弹出来了，并且在指定的位置弹出相应的窗口。

②在showarrow这个方法，我们需要根据是否向上还是向下显示相应的箭头，给用户一个很好的提示。

③在动画的操作方法中，我们要根据其坐标是否小于全频宽度的四分之一位置，从左边的位置弹出来，其坐标从全频宽度四分之三的位置，从右侧位置弹出来了。

有了这篇文章介绍，主界面应该了解了把？下节介绍收藏和历史界面。