一、项目概述

本系统包含高考、四级、六级、托福和雅思词汇五个章节。每个章节分为多个单元，每个单元又包含上百个词汇。可以在单元列表查询单词，实时记录每个单元的阅读时间，点进单词详情页，有单词的拼写、音标、释义和例句，底部导航栏可以查看前一页和后一页，还可以进行自动播放，可以手动滑动页面，右上角可以设置播放速度。是一款很给力的记单词软件。

二、主要技术

主要应用的技术如下：

Fragment碎片	ViewPager	SharedPreferences	MediaPlayer	Adapter
Handler消息机制	SQLiteDatabase	Bundle	SQLiteOpenHelper	SharedPreferences
FileOutputStream	Timer	MediaPlayer	Dialog	ListView

本项目知识点还是很多的，虽然看起来功能不算多，但是实现起来很不容易。

三、开发环境

开发环境依旧是在3.5.1上进行开发的，只要你的AS是近两年从官网下载的，都是可以满足的。

四、详细设计

1、数据库

本项目的数据库采用已有的单词数据库word.db文件，通过读文件的方式，从数据库中读取存储的单词数据。

public SQLiteDatabase getDatabase() {
   
    String path = mContext.getDir(Const.DB_DIR, Context.MODE_PRIVATE) + File.separator + Const.DB_NAME;
    return SQLiteDatabase.openDatabase(path, null, SQLiteDatabase.OPEN_READWRITE);
}

与以往的数据库帮助类不同，这次并没有提前创建好数据库和表，而是在欢迎活动中调用构造函数进行创建，创建之后会自动执行建表语句。

  // 创建数据库和表
 private void initTable() {
   
     DBOpenHelper dbOpenHelper = DBOpenHelper.getInstance(this);
     SQLiteDatabase database = dbOpenHelper.getDatabase();
     database.execSQL("create table if not exists TABLE_UNIT (" +
             "Unit_Key integer not null," +
             "Unit_Time integer not null default 0," +
             "Cate_Key text references TABLE_META(Meta_Key)" +
             ");");
     for (String metaKey : Const.META_KEYS) {
   
         Cursor cursor = database.rawQuery("select Meta_UnitCount from TABLE_META where Meta_Key=?;"
                 , new String[]{
   metaKey});
         if (cursor.moveToFirst()) {
   
             int count = cursor.getInt(cursor.getColumnIndex("Meta_UnitCount"));
             for (int i = 1; i <= count; i++) {
   
                 database.execSQL("insert into TABLE_UNIT (Unit_Key,Unit_Time,Cate_Key) " +
                         "values(?,?,?);", new Object[]{
   i, 0, metaKey});
             }
         }
         cursor.close();
     }
 }

2、单词详情

首先肯定创建单词和单元的实体类，其实就是数据表的结构。类的内容就是：类的属性、构造函数、get和set方法。

/**
 * 单词实体类
 */
public class Word implements Parcelable {
   
    //Word_Id, Word_Key, Word_Phono, Word_Trans, Word_Example, Word_Unit;
    private int mId;
    private String mKey;
    private String mPhono;
    private String mTrans;
    private String mExample;
    private int mUnit;

    public Word() {
   
    }

    public Word(int id, String key, String phono, String trans, String example, int unit) {
   
        mId = id;
        mKey = key;
        mPhono = phono;
        mTrans = trans;
        mExample = example;
        mUnit = unit;
    }

    public int getId() {
   
        return mId;
    }

    public void setId(int id) {
   
        mId = id;
    }

    public String getKey() {
   
        return mKey;
    }

    public void setKey(String key) {
   
        mKey = key;
    }

    public String getPhono() {
   
        return mPhono;
    }

    public void setPhono(String phono) {
   
        mPhono = phono;
    }

    public String getTrans() {
   
        return mTrans;
    }

    public void setTrans(String trans) {
   
        mTrans = trans;
    }

    public String getExample() {
   
        return mExample;
    }

    public void setExample(String example) {
   
        mExample = example;
    }

    public int getUnit() {
   
        return mUnit;
    }

    public void setUnit(int unit) {
   
        mUnit = unit;
    }

    @Override
    public int describeContents() {
   
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
   
        dest.writeInt(this.mId);
        dest.writeString(this.mKey);
        dest.writeString(this.mPhono);
        dest.writeString(this.mTrans);
        dest.writeString(this.mExample);
        dest.writeInt(this.mUnit);
    }

    protected Word(Parcel in) {
   
        this.mId = in.readInt();
        this.mKey = in.readString();
        this.mPhono = in.readString();
        this.mTrans = in.readString();
        this.mExample = in.readString();
        this.mUnit = in.readInt();
    }

    public static final Parcelable.Creator<Word> CREATOR = new Parcelable.Creator<Word>() {
   
        public Word createFromParcel(Parcel source) {
   
            return new Word(source);
        }

        public Word[] newArray(int size) {
   
            return new Word[size];
        }
    };
}

单词详情包含单词的拼写、单词的音标、单词的释义和单词的例句，通过数据库方法获取到单词的这些信息，然后依次填入TextView中，具体实现起来肯定还有很多细节点。

public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
   
    View view = inflater.inflate(R.layout.fragment_detail, container, false);
    TextView tvExample = (TextView) view.findViewById(R.id.tv_exam);
    TextView tvKey = (TextView) view.findViewById(R.id.tv_key);
    TextView tvPhono = (TextView) view.findViewById(R.id.tv_phono);
    TextView tvTrans = (TextView) view.findViewById(R.id.tv_trans);
    final Word word = getArguments().getParcelable(Const.WORD_KEY);
    mImageView = (ImageView) view.findViewById(R.id.icon_speech);
    mImageView.setOnClickListener(new View.OnClickListener() {
   
        @Override
        public void onClick(View v) {
   
            if (mOnSpeechListener != null) {
   
                mOnSpeechListener.speech(word);
            }
        }
    });
    if (word != null) {
   
        tvExample.setText(word.getExample());
        tvKey.setText(word.getKey());
        tvPhono.setText("[" + word.getPhono() + "]");
        tvTrans.setText(word.getTrans());
    }
    return view;
}

3、搜索单词

在点击搜索框时，定义了mSearchFgt，用mSearchFgt的fragment先替换UnitList的fragment，然后在检测搜索框中有内容时，通过onQueryTextChange方法获取数据源，并通知适配器更新数据源。

@Override
public boolean onCreateOptionsMenu(Menu menu) {
   
    getMenuInflater().inflate(R.menu.menu_search, menu);
    MenuItem item = menu.findItem(R.id.menu_item_search);
    mSearchView = (SearchView) item.getActionView();
    if (mSearchView != null) {
   
        mSearchView.setInputType(InputType.TYPE_CLASS_TEXT);
        mSearchView.setOnSearchClickListener(new View.OnClickListener() {
   
            @Override
            public void onClick(View v) {
   
                mActionBar.setDisplayHomeAsUpEnabled(true);
                mWordDao = new WordDao(UnitListActivity.this);
                FragmentTransaction transaction = mFragmentManager.beginTransaction();
                transaction.hide(mUnitListFgt);
                if (mSearchFgt == null) {
   
                    mSearchFgt = SearchFgt.newInstance(mMetaKey);
                    transaction.add(R.id.unit_content, mSearchFgt);
                } else {
   
                    transaction.show(mSearchFgt);
                }
                transaction.commit();
            }
        });
        mSearchView.setQueryHint(getString(R.string.search_hint));
        mSearchView.setOnQueryTextListener(this);
    }
    return true;
}

 @Override
 public boolean onQueryTextChange(String newText) {
   
     ArrayList<Word> words = null;
     if (!TextUtils.isEmpty(newText)) {
   
         words = mWordDao.queryWords(mMetaKey, newText);
     }
     mSearchFgt.refresh(words);
     return true;
 }