揭秘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开发的原则：凡是耗时操作，应该开启多线程，再相应线程回调完成后再更新界面。

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