揭秘uc浏览器三

这节我们主要讨论收藏与历史记录页面的边边角角。

首先，看看他的最终的效果图了：

照例了，我们先看看他的布局文件：

<!-- tab布局文件 -->
<TabHost xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@android:id/tabhost"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">
    <LinearLayout
        android:orientation="vertical"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        android:padding="5dp">
        <TabWidget
            android:id="@android:id/tabs"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content" />
        <!-- 相应桢布局 -->
        <FrameLayout
            android:id="@android:id/tabcontent"
            android:layout_width="fill_parent"
            android:layout_height="fill_parent"
            android:padding="5dp" />
    </LinearLayout>
</TabHost>

相应的布局文件说明如下：

别开这是一个布局文件其实涉及另外两个布局文件，相应布局文件是左右两边布局文件。他两个布局文件源代码又是怎么样了？一个是书签页面的布局文件，一个是历史记录的布局文件。但是布局文件共拥有一个布局文件。

相应源代码如下：

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">
    <!-- list 控件 -->
    <ListView 
          android:id="@+id/BookmarksListActivity.List"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"/>
        <!-- 文本控件 -->
  <TextView android:id="@+id/BookmarksListActivity.EmptyTextView"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:gravity="center_horizontal"
        android:layout_gravity="center_vertical"
        android:text="@string/BookmarksListActivity.Empty"/>

</LinearLayout>

一个list控件加一个文本控件就ok了。

布局文件，一直都不是android工程中重头戏。java文件又是什么样子了？

我们来看看他所涉及的相应的java文件。

 首先，我们看一下书签历史记录页面的java 源代码，他在这里的控制作用也只有一种抛砖引玉的作用了.

/**
 * 这是一个historyactivity
 */
public class BookmarksHistoryActivity extends TabActivity {

    /**
     * 创建的方法
     */
    @Override
    protected void onCreate(Bundle savedInstanceState) {        
        super.onCreate(savedInstanceState);
        
        if (Controller.getInstance().getPreferences().getBoolean(Constants.PREFERENCES_SHOW_FULL_SCREEN, false)) {            
            getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
        }
        
        if (Controller.getInstance().getPreferences().getBoolean(Constants.PREFERENCES_GENERAL_HIDE_TITLE_BARS, true)) {
            requestWindowFeature(Window.FEATURE_NO_TITLE);
        }
        
        setContentView(R.layout.bookmarks_history_activity);
        
        setTitle(R.string.BookmarksListActivity_Title);
        
        Resources res = getResources();
        TabHost tabHost = getTabHost();
        TabHost.TabSpec spec;
        Intent intent;
        
        // Bookmarks
        intent = new Intent().setClass(this, BookmarksListActivity.class);
        
        spec = tabHost.newTabSpec("bookmarks").setIndicator(res.getString(R.string.Main_MenuShowBookmarks),
                res.getDrawable(R.drawable.ic_tab_bookmarks))
                .setContent(intent);
        tabHost.addTab(spec);
        
        // History
        intent = new Intent().setClass(this, HistoryListActivity.class);

        spec = tabHost.newTabSpec("history").setIndicator(res.getString(R.string.Main_MenuShowHistory),
                res.getDrawable(R.drawable.ic_tab_history))
                .setContent(intent);
        tabHost.addTab(spec);

        if (PreferenceManager.getDefaultSharedPreferences(this).getBoolean(Constants.PREFERENCE_USE_WEAVE, false)) {
            // Weave bookmarks
            intent = new Intent().setClass(this, WeaveBookmarksListActivity.class);

            spec = tabHost.newTabSpec("weave").setIndicator(res.getString(R.string.WeaveBookmarksListActivity_Title),
                    res.getDrawable(R.drawable.ic_tab_weave))
                    .setContent(intent);
            tabHost.addTab(spec);
        }
        
        tabHost.setCurrentTab(0);
        
        tabHost.setOnTabChangedListener(new OnTabChangeListener() {            
            @Override
            public void onTabChanged(String tabId) {
                if (tabId.equals("bookmarks")) {
                    setTitle(R.string.BookmarksListActivity_Title);
                } else if (tabId.equals("history")) {
                    setTitle(R.string.HistoryListActivity_Title);
                } else if (tabId.equals("weave")) {
                    setTitle(R.string.WeaveBookmarksListActivity_Title);
                } else {
                    setTitle(R.string.ApplicationName);
                }
            }
        });
    }
    
    /**
     * 配置文件改变的方法
     */
    @Override
    public void onConfigurationChanged(Configuration newConfig) {
        super.onConfigurationChanged(newConfig);
    }
}

我们可以总结出来以下几个结果：

①在oncreate这个方法中，能否全频，能否有标题，这些设置的配置的参数就是存在与preference这个参数中的，可以sharedpreference这个对象保存配置参数，这也是android官方推荐的一种方式。

②一看这个布局的方式，这是一个典型tab布局，因此我们要实例化相应tabhost文件，并且为相应tabhost赋值事件，进入不同的intent，并且进入不同的界面后，赋值相应的标题。

③将相应的配置文件改变以后的，父类的配置文件也进行相应的改变。

由于要跳往不同的界面，所以就需要两个文件控制。

 首先看一下 BookmarksListActivity中的控制文件，相应的源代码如下：

public class BookmarksListActivity extends Activity {
            
    private static final int MENU_ADD_BOOKMARK = Menu.FIRST;
    private static final int MENU_SORT_MODE = Menu.FIRST + 1;
    
    private static final int MENU_OPEN_IN_TAB = Menu.FIRST + 10;    
    private static final int MENU_COPY_URL = Menu.FIRST + 11;
    private static final int MENU_SHARE = Menu.FIRST + 12;
    private static final int MENU_EDIT_BOOKMARK = Menu.FIRST + 13;
    private static final int MENU_DELETE_BOOKMARK = Menu.FIRST + 14;
    
    private static final int ACTIVITY_ADD_BOOKMARK = 0;
    private static final int ACTIVITY_EDIT_BOOKMARK = 1;
    
    private Cursor mCursor;
    private BookmarksCursorAdapter mCursorAdapter;
    
    private ListView mList;
    
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.bookmarks_list_activity);
        
        setTitle(R.string.BookmarksListActivity_Title);
        
        View emptyView = findViewById(R.id.BookmarksListActivity_EmptyTextView);
        mList = (ListView) findViewById(R.id.BookmarksListActivity_List);
        
        mList.setEmptyView(emptyView);
        
        mList.setOnItemClickListener(new OnItemClickListener() {

            @Override
            public void onItemClick(AdapterView<?> l, View v, int position, long id) {
                Intent result = new Intent();
                result.putExtra(Constants.EXTRA_ID_NEW_TAB, false);
                
                BookmarkItem item = BookmarksProviderWrapper.getStockBookmarkById(getContentResolver(), id);
                if (item != null) {
                    result.putExtra(Constants.EXTRA_ID_URL,  item.getUrl());
                } else {
                    result.putExtra(Constants.EXTRA_ID_URL,
                            PreferenceManager.getDefaultSharedPreferences(BookmarksListActivity.this).getString(Constants.PREFERENCES_GENERAL_HOME_PAGE, Constants.URL_ABOUT_START));
                }
                
                if (getParent() != null) {
                    getParent().setResult(RESULT_OK, result);
                } else {
                    setResult(RESULT_OK, result);
                }
                
                finish();
            }
        });

        registerForContextMenu(mList);
        
        fillData();
    }
    
    @Override
    protected void onDestroy() {
        mCursor.close();
        super.onDestroy();
    }

    /**
     * Fill the bookmark to the list UI. 
     */
    private void fillData() {
        mCursor = BookmarksProviderWrapper.getStockBookmarks(getContentResolver(),
                PreferenceManager.getDefaultSharedPreferences(this).getInt(Constants.PREFERENCES_BOOKMARKS_SORT_MODE, 0));
        startManagingCursor(mCursor);
        
        String[] from = new String[] { Browser.BookmarkColumns.TITLE, Browser.BookmarkColumns.URL};
        int[] to = new int[] {R.id.BookmarkRow_Title, R.id.BookmarkRow_Url};
        
        mCursorAdapter = new BookmarksCursorAdapter(this,
                R.layout.bookmark_row,
                mCursor,
                from,
                to,
                ApplicationUtils.getFaviconSizeForBookmarks(this));
        
        mList.setAdapter(mCursorAdapter);
        
        setAnimation();
    }
    
    /**
     * Set the list loading animation.
     */
    private void setAnimation() {
        AnimationSet set = new AnimationSet(true);

        Animation animation = new AlphaAnimation(0.0f, 1.0f);
        animation.setDuration(100);
        set.addAnimation(animation);

        animation = new TranslateAnimation(
            Animation.RELATIVE_TO_SELF, 0.0f, Animation.RELATIVE_TO_SELF, 0.0f,
            Animation.RELATIVE_TO_SELF, -1.0f, Animation.RELATIVE_TO_SELF, 0.0f
        );
        animation.setDuration(100);
        set.addAnimation(animation);

        LayoutAnimationController controller =
                new LayoutAnimationController(set, 0.5f);

        mList.setLayoutAnimation(controller);
    }
    
    /**
     * Display the add bookmark dialog.
     */
    private void openAddBookmarkDialog() {
        Intent i = new Intent(this, EditBookmarkActivity.class);
        
        i.putExtra(Constants.EXTRA_ID_BOOKMARK_ID, (long) -1);
        i.putExtra(Constants.EXTRA_ID_BOOKMARK_TITLE, "");
        i.putExtra(Constants.EXTRA_ID_BOOKMARK_URL, "");
        
        startActivityForResult(i, ACTIVITY_ADD_BOOKMARK);
    }
    
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        super.onCreateOptionsMenu(menu);
        
        MenuItem item;
        item = menu.add(0, MENU_ADD_BOOKMARK, 0, R.string.BookmarksListActivity_MenuAddBookmark);
        item.setIcon(R.drawable.ic_menu_add_bookmark);
        
        item = menu.add(0, MENU_SORT_MODE, 0, R.string.BookmarksListActivity_MenuSortMode);
        item.setIcon(R.drawable.ic_menu_sort);                
        
        return true;
    }
    
    @Override
    public boolean onMenuItemSelected(int featureId, MenuItem item) {
        
        switch(item.getItemId()) {
        case MENU_SORT_MODE:
            changeSortMode();
            return true;
            
        case MENU_ADD_BOOKMARK:            
            openAddBookmarkDialog();
            return true;
            
        default: return super.onMenuItemSelected(featureId, item);
        }
    }
    
    @Override
    public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
        super.onCreateContextMenu(menu, v, menuInfo);
        
        long id = ((AdapterContextMenuInfo) menuInfo).id;
        if (id != -1) {
            BookmarkItem item = BookmarksProviderWrapper.getStockBookmarkById(getContentResolver(), id);
            if (item != null) {
                menu.setHeaderTitle(item.getTitle());
            }
        }
        
        menu.add(0, MENU_OPEN_IN_TAB, 0, R.string.BookmarksListActivity_MenuOpenInTab);        
        menu.add(0, MENU_COPY_URL, 0, R.string.BookmarksHistoryActivity_MenuCopyLinkUrl);
        menu.add(0, MENU_SHARE, 0, R.string.Main_MenuShareLinkUrl);
        menu.add(0, MENU_EDIT_BOOKMARK, 0, R.string.BookmarksListActivity_MenuEditBookmark);
        menu.add(0, MENU_DELETE_BOOKMARK, 0, R.string.BookmarksListActivity_MenuDeleteBookmark);
    }
    
    @Override
    public boolean onContextItemSelected(MenuItem item) {
        AdapterContextMenuInfo info = (AdapterContextMenuInfo) item.getMenuInfo();
                
        Intent i;
        BookmarkItem bookmarkItem = BookmarksProviderWrapper.getStockBookmarkById(getContentResolver(), info.id);
        
        switch (item.getItemId()) {
        case MENU_OPEN_IN_TAB:        
            i = new Intent();
            i.putExtra(Constants.EXTRA_ID_NEW_TAB, true);
            
            if (bookmarkItem != null) {
                i.putExtra(Constants.EXTRA_ID_URL,  bookmarkItem.getUrl());
            } else {
                i.putExtra(Constants.EXTRA_ID_URL,
                        PreferenceManager.getDefaultSharedPreferences(BookmarksListActivity.this).getString(Constants.PREFERENCES_GENERAL_HOME_PAGE, Constants.URL_ABOUT_START));
            }
            
            if (getParent() != null) {
                getParent().setResult(RESULT_OK, i);
            } else {
                setResult(RESULT_OK, i);            
            }
            
            finish();
            return true;
            
        case MENU_EDIT_BOOKMARK:            
            if (bookmarkItem != null) {
                i = new Intent(this, EditBookmarkActivity.class);
                i.putExtra(Constants.EXTRA_ID_BOOKMARK_ID, info.id);
                i.putExtra(Constants.EXTRA_ID_BOOKMARK_TITLE, bookmarkItem.getTitle());
                i.putExtra(Constants.EXTRA_ID_BOOKMARK_URL, bookmarkItem.getUrl());

                startActivityForResult(i, ACTIVITY_EDIT_BOOKMARK);
            }
            return true;
            
        case MENU_COPY_URL:
            if (bookmarkItem != null) {
                ApplicationUtils.copyTextToClipboard(this,  bookmarkItem.getUrl(), getString(R.string.Commons_UrlCopyToastMessage));
            }
            return true;
            
        case MENU_SHARE:
            if (bookmarkItem != null) {
                ApplicationUtils.sharePage(this, bookmarkItem.getTitle(), bookmarkItem.getUrl());
            }
            return true;
            
        case MENU_DELETE_BOOKMARK:
            //mDbAdapter.deleteBookmark(info.id);
            BookmarksProviderWrapper.deleteStockBookmark(getContentResolver(), info.id);
            fillData();
            return true;
        default: return super.onContextItemSelected(item);
        }
    }
    
    /**
     * Change list sort mode. Update list.
     * @param sortMode The new sort mode.
     */
    private void doChangeSortMode(int sortMode) {
        Editor editor = PreferenceManager.getDefaultSharedPreferences(this).edit();
        editor.putInt(Constants.PREFERENCES_BOOKMARKS_SORT_MODE, sortMode);
        editor.commit();
        
        fillData();
    }
    
    /**
     * Show a dialog for choosing the sort mode.
     * Perform the change if required.
     */
    private void changeSortMode() {
        
        int currentSort = PreferenceManager.getDefaultSharedPreferences(this).getInt(Constants.PREFERENCES_BOOKMARKS_SORT_MODE, 0);
        
        AlertDialog.Builder builder = new AlertDialog.Builder(this);
        builder.setInverseBackgroundForced(true);
        builder.setIcon(android.R.drawable.ic_dialog_info);
        builder.setTitle(getResources().getString(R.string.BookmarksListActivity_MenuSortMode));
        builder.setSingleChoiceItems(new String[] {getResources().getString(R.string.BookmarksListActivity_MostUsedSortMode),
                getResources().getString(R.string.BookmarksListActivity_AlphaSortMode),
                getResources().getString(R.string.BookmarksListActivity_RecentSortMode) },
                currentSort,
                new OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                doChangeSortMode(which);
                dialog.dismiss();                
            }            
        }); 
        builder.setCancelable(true);
        builder.setNegativeButton(R.string.Commons_Cancel, null);
        
        AlertDialog alert = builder.create();
        alert.show();
    }
    
    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent intent) {
        super.onActivityResult(requestCode, resultCode, intent);
        
        switch (requestCode) {
        case ACTIVITY_EDIT_BOOKMARK:
            if (resultCode == RESULT_OK) {
                fillData();
            }
            break;
        case ACTIVITY_ADD_BOOKMARK:
            if (resultCode == RESULT_OK) {
                fillData();
            }
            break;
            
        default:
            break;
        }
    }

}

①同理在oncreate方法，实例化相应的listview，把从ContentResolver取得的网址信息，添加到相应的listview中去，并且为listview赋值与每项目的点击事件，每项的点击跳转到相应的界面上去。同时结束当前的界面。

②在方法中实现数据的填充，同时还为列表绑定上下文菜单。

③程序也是一环扣一环的，那么这个fillData方法是加载数据的方法，又是如何实现的了，把数据库存标签的数据按照一定方式（分页的方式）读取出来，并且加载到相应的列表上去。这个加载数据的过程中有一个淡入淡出动画的效果。

④你要添加这个标签对话框也是在此界面上完成这个功能的，我们用了回调结果intent来跳转到相应编辑标签的界面，编辑标签以后，在到回调结果方法中重新进行相应数据的重新初始化。

⑤这个文件大量的篇幅用于一些上下文菜单的处理，分别对相应在tab打开网页菜单，编辑标签的菜单，复制URL的菜单，分享的菜单，删除菜单的事件做一个处理。

接下来，是一个HistoryListActivity源代码控制文件的解析。源代码如下：

/**
 * history list activity.
 */
public class HistoryListActivity extends ExpandableListActivity {
    
    private static final int MENU_CLEAR_HISTORY = Menu.FIRST;
    
    private static final int MENU_OPEN_IN_TAB = Menu.FIRST + 10;
    private static final int MENU_COPY_URL = Menu.FIRST + 11;
    private static final int MENU_SHARE = Menu.FIRST + 12;
    private static final int MENU_DELETE_FROM_HISTORY = Menu.FIRST + 13;
    
    private ExpandableListAdapter mAdapter;
    
    private ProgressDialog mProgressDialog;
    
    private OnCheckedChangeListener mBookmarkStarChangeListener;
    
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        
        setTitle(R.string.HistoryListActivity_Title);
        
        registerForContextMenu(getExpandableListView());
        
        mBookmarkStarChangeListener = new OnCheckedChangeListener() {            
            @Override
            public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {                                
                long id = (Long) buttonView.getTag();
                BookmarksProviderWrapper.toggleBookmark(getContentResolver(), id, isChecked);
                
                if (isChecked) {
                    Toast.makeText(HistoryListActivity.this, R.string.HistoryListActivity_BookmarkAdded, Toast.LENGTH_SHORT).show();
                } else {
                    Toast.makeText(HistoryListActivity.this, R.string.HistoryListActivity_BookmarkRemoved, Toast.LENGTH_SHORT).show();
                }
            }
        };
        
        fillData();
    }

    /**
     * Fill the history list.
     */
    private void fillData() {
        Cursor c = BookmarksProviderWrapper.getStockHistory(getContentResolver());
        
        mAdapter = new HistoryExpandableListAdapter(
                this,
                mBookmarkStarChangeListener,
                c,
                c.getColumnIndex(Browser.BookmarkColumns.DATE),
                ApplicationUtils.getFaviconSizeForBookmarks(this));
        
        setListAdapter(mAdapter);
        
        if (getExpandableListAdapter().getGroupCount() > 0) {
            getExpandableListView().expandGroup(0);
        }
    }
    
    @Override
    public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
        super.onCreateContextMenu(menu, v, menuInfo);
        
        ExpandableListView.ExpandableListContextMenuInfo info =
            (ExpandableListView.ExpandableListContextMenuInfo) menuInfo;

        int type = ExpandableListView.getPackedPositionType(info.packedPosition);
        int group = ExpandableListView.getPackedPositionGroup(info.packedPosition);
        int child =    ExpandableListView.getPackedPositionChild(info.packedPosition);
        
        if (type == ExpandableListView.PACKED_POSITION_TYPE_CHILD) {
            
            HistoryItem item = (HistoryItem) getExpandableListAdapter().getChild(group, child);
            menu.setHeaderTitle(item.getTitle());
            
            menu.add(0, MENU_OPEN_IN_TAB, 0, R.string.HistoryListActivity_MenuOpenInTab);
            menu.add(0, MENU_COPY_URL, 0, R.string.BookmarksHistoryActivity_MenuCopyLinkUrl);
            menu.add(0, MENU_SHARE, 0, R.string.Main_MenuShareLinkUrl);
            menu.add(0, MENU_DELETE_FROM_HISTORY, 0, R.string.HistoryListActivity_MenuDelete);
        }
    }
    
    @Override
    public boolean onContextItemSelected(MenuItem menuItem) {
        ExpandableListContextMenuInfo info = (ExpandableListContextMenuInfo) menuItem.getMenuInfo();
        
        int type = ExpandableListView.getPackedPositionType(info.packedPosition);
        
        if (type == ExpandableListView.PACKED_POSITION_TYPE_CHILD) {
            int group = ExpandableListView.getPackedPositionGroup(info.packedPosition);
            int child =    ExpandableListView.getPackedPositionChild(info.packedPosition);
            
            HistoryItem item = (HistoryItem) getExpandableListAdapter().getChild(group, child);
            
            switch (menuItem.getItemId()) {
            case MENU_OPEN_IN_TAB:
                doNavigateToUrl(item.getUrl(), true);
                break;
            case MENU_COPY_URL:
                ApplicationUtils.copyTextToClipboard(this, item.getUrl(), getString(R.string.Commons_UrlCopyToastMessage));
                break;
            case MENU_SHARE:
                ApplicationUtils.sharePage(this, item.getTitle(), item.getUrl());
                break;
            case MENU_DELETE_FROM_HISTORY:
                BookmarksProviderWrapper.deleteHistoryRecord(getContentResolver(), item.getId());
                fillData();
                break;
            default:
                break;
            }
        }
        
        return super.onContextItemSelected(menuItem);
    }
    
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        super.onCreateOptionsMenu(menu);
        
        MenuItem item;
        item = menu.add(0, MENU_CLEAR_HISTORY, 0, R.string.Commons_ClearHistory);
        item.setIcon(R.drawable.ic_menu_delete);
        
        return true;
    }
    
    @Override
    public boolean onMenuItemSelected(int featureId, MenuItem item) {
        
        switch(item.getItemId()) {
        case MENU_CLEAR_HISTORY:
            clearHistory();
            return true;
        default: return super.onMenuItemSelected(featureId, item);
        }
    }
    
    @Override
    public boolean onChildClick(ExpandableListView parent, View v,    int groupPosition, int childPosition, long id) {
        HistoryItem item = (HistoryItem) getExpandableListAdapter().getChild(groupPosition, childPosition);
        doNavigateToUrl(item.getUrl(), false);
        
        return super.onChildClick(parent, v, groupPosition, childPosition, id);
    }
    
    /**
     * Load the given url.
     * @param url The url.
     * @param newTab If True, will open a new tab. If False, the current tab is used.
     */
    private void doNavigateToUrl(String url, boolean newTab) {
        Intent result = new Intent();
        result.putExtra(Constants.EXTRA_ID_NEW_TAB, newTab);
        result.putExtra(Constants.EXTRA_ID_URL,  url);
        
        if (getParent() != null) {
            getParent().setResult(RESULT_OK, result);
        } else {
            setResult(RESULT_OK, result);
        }
        finish();
    }

    /**
     * Clear history.
     */
    private void doClearHistory() {
        mProgressDialog = ProgressDialog.show(this,
                this.getResources().getString(R.string.Commons_PleaseWait),
                this.getResources().getString(R.string.Commons_ClearingHistory));
        
        new HistoryClearer();
    }
    
    /**
     * Display confirmation and clear history.
     */
    private void clearHistory() {
        ApplicationUtils.showYesNoDialog(this,
                android.R.drawable.ic_dialog_alert,
                R.string.Commons_ClearHistory,
                R.string.Commons_NoUndoMessage,
                new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        dialog.dismiss();
                        doClearHistory();
                    }            
        });
    }
    
    /**
     * Runnable to clear history.
     */
    private class HistoryClearer implements Runnable {

        /**
         * Constructor.
         */
        public HistoryClearer() {
            new Thread(this).start();
        }

        @Override
        public void run() {
            BookmarksProviderWrapper.clearHistoryAndOrBookmarks(getContentResolver(), true, false);
            
            for (CustomWebView webView : Controller.getInstance().getWebViewList()) {
                webView.clearHistory();
            }
            
            handler.sendEmptyMessage(0);
        }

        private Handler handler = new Handler() {
            public void handleMessage(Message msg) {
                mProgressDialog.dismiss();
                fillData();
            }
        };
    }
    
}

观察相应的源代码了，我们可想而知其大体与标签列表界面的大体一样，上面说过方法就不做过多的赘述了，这里我们只需要阐述了为什么要HistoryClearer这个开启线程来清空历史记录。 首先原因有二：

①由于打开网页是很多很多，这里面数据还是很多很多。

②正视由于数据量大，这是一个耗时操作，如果放在一个ui线程中势必会造成页面假使，极大的影响了用户体验。开启一个线程，使其在回调后，更新界面，符合提升用户体验的原则。

我们再这里可以得出来这样android开发的原则：凡是耗时操作，应该开启多线程，再相应线程回调完成后再更新界面。

这就是我对标签记录页面总结，和一点点总结。