public static int lowestOneBit(int i) {
  return i & -i;
 }

public static byte[] removeUTF8BOM(byte[] bt) {
    if (bt != null && bt.length > 3) {
         // 前三个字节依次是 EF BB BF
         if (bt[0] == -17 && bt[1] == -69 && bt[2] == -65) {
                 byte[] nbs = new byte[bt.length - 3];
                 System.arraycopy(bt, 3, nbs, 0, nbs.length);
                 return nbs;
         }
     }
     return bt;
 }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //打开或创建test.db数据库
        SQLiteDatabase db = openOrCreateDatabase("test.db", Context.MODE_PRIVATE, null);
        db.execSQL("DROP TABLE IF EXISTS person");
        //创建person表
        db.execSQL("CREATE TABLE person (_id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR, age SMALLINT)");
        Person person = new Person();
        person.name = "john";
        person.age = 30;
        //插入数据
        db.execSQL("INSERT INTO person VALUES (NULL, ?, ?)", new Object[]{person.name, person.age});
        person.name = "david";
        person.age = 33;
        //ContentValues以键值对的形式存放数据
        ContentValues cv = new ContentValues();
        cv.put("name", person.name);
        cv.put("age", person.age);
        //插入ContentValues中的数据
        db.insert("person", null, cv);
        cv = new ContentValues();
        cv.put("age", 35);
        //更新数据
        db.update("person", cv, "name = ?", new String[]{"john"});
        Cursor c = db.rawQuery("SELECT * FROM person WHERE age >= ?", new String[]{"33"});
        while (c.moveToNext()) {
            int _id = c.getInt(c.getColumnIndex("_id"));
            String name = c.getString(c.getColumnIndex("name"));
            int age = c.getInt(c.getColumnIndex("age"));
            Log.i("db", "_id=>" + _id + ", name=>" + name + ", age=>" + age);
        }
        c.close();
        //删除数据
        db.delete("person", "age < ?", new String[]{"35"});
        //关闭当前数据库
        db.close();
        //删除test.db数据库
//      deleteDatabase("test.db");
    }

db.executeSQL(String sql);
db.executeSQL(String sql, Object[] bindArgs);//sql语句中使用占位符，然后第二个参数是实际的参数集

db.insert(String table, String nullColumnHack, ContentValues values);
db.update(String table, Contentvalues values, String whereClause, String whereArgs);
db.delete(String table, String whereClause, String whereArgs);

db.rawQuery(String sql, String[] selectionArgs);
db.query(String table, String[] columns, String selection, String[] selectionArgs, String groupBy, String having, String orderBy);
db.query(String table, String[] columns, String selection, String[] selectionArgs, String groupBy, String having, String orderBy, String limit);
db.query(String distinct, String table, String[] columns, String selection, String[] selectionArgs, String groupBy, String having, String orderBy, String limit);

c.move(int offset); //以当前位置为参考,移动到指定行
c.moveToFirst();    //移动到第一行
c.moveToLast();     //移动到最后一行
c.moveToPosition(int position); //移动到指定行
c.moveToPrevious(); //移动到前一行
c.moveToNext();     //移动到下一行
c.isFirst();        //是否指向第一条
c.isLast();     //是否指向最后一条
c.isBeforeFirst();  //是否指向第一条之前
c.isAfterLast();    //是否指向最后一条之后
c.isNull(int columnIndex);  //指定列是否为空(列基数为0)
c.isClosed();       //游标是否已关闭
c.getCount();       //总数据项数
c.getPosition();    //返回当前游标所指向的行数
c.getColumnIndex(String columnName);//返回某列名对应的列索引值
c.getString(int columnIndex);   //返回当前行指定列的值

package com.scott.db;
import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
public class DBHelper extends SQLiteOpenHelper {
    private static final String DATABASE_NAME = "test.db";
    private static final int DATABASE_VERSION = 1;
    public DBHelper(Context context) {
        //CursorFactory设置为null,使用默认值
        super(context, DATABASE_NAME, null, DATABASE_VERSION);
    }
    //数据库第一次被创建时onCreate会被调用
    @Override
    public void onCreate(SQLiteDatabase db) {
        db.execSQL("CREATE TABLE IF NOT EXISTS person" +
                "(_id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR, age INTEGER, info TEXT)");
    }
    //如果DATABASE_VERSION值被改为2,系统发现现有数据库版本不同,即会调用onUpgrade
    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        db.execSQL("ALTER TABLE person ADD COLUMN other STRING");
    }
}

package com.scott.db;
public class Person {
    public int _id;
    public String name;
    public int age;
    public String info;
    public Person() {
    }
    public Person(String name, int age, String info) {
        this.name = name;
        this.age = age;
        this.info = info;
    }
}

package com.scott.db;
import java.util.ArrayList;
import java.util.List;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
public class DBManager {
    private DBHelper helper;
    private SQLiteDatabase db;
    public DBManager(Context context) {
        helper = new DBHelper(context);
        //因为getWritableDatabase内部调用了mContext.openOrCreateDatabase(mName, 0, mFactory);
        //所以要确保context已初始化,我们可以把实例化DBManager的步骤放在Activity的onCreate里
        db = helper.getWritableDatabase();
    }
    /**
     * add persons
     * @param persons
     */
    public void add(List<Person> persons) {
        db.beginTransaction();  //开始事务
        try {
            for (Person person : persons) {
                db.execSQL("INSERT INTO person VALUES(null, ?, ?, ?)", new Object[]{person.name, person.age, person.info});
            }
            db.setTransactionSuccessful();  //设置事务成功完成
        } finally {
            db.endTransaction();    //结束事务
        }
    }
    /**
     * update person's age
     * @param person
     */
    public void updateAge(Person person) {
        ContentValues cv = new ContentValues();
        cv.put("age", person.age);
        db.update("person", cv, "name = ?", new String[]{person.name});
    }
    /**
     * delete old person
     * @param person
     */
    public void deleteOldPerson(Person person) {
        db.delete("person", "age >= ?", new String[]{String.valueOf(person.age)});
    }
    /**
     * query all persons, return list
     * @return List<Person>
     */
    public List<Person> query() {
        ArrayList<Person> persons = new ArrayList<Person>();
        Cursor c = queryTheCursor();
        while (c.moveToNext()) {
            Person person = new Person();
            person._id = c.getInt(c.getColumnIndex("_id"));
            person.name = c.getString(c.getColumnIndex("name"));
            person.age = c.getInt(c.getColumnIndex("age"));
            person.info = c.getString(c.getColumnIndex("info"));
            persons.add(person);
        }
        c.close();
        return persons;
    }
    /**
     * query all persons, return cursor
     * @return  Cursor
     */
    public Cursor queryTheCursor() {
        Cursor c = db.rawQuery("SELECT * FROM person", null);
        return c;
    }
    /**
     * close database
     */
    public void closeDB() {
        db.close();
    }
}

public synchronized SQLiteDatabase getReadableDatabase() {
    if (mDatabase != null && mDatabase.isOpen()) {
        // 如果发现mDatabase不为空并且已经打开则直接返回
        return mDatabase;
    }
    if (mIsInitializing) {
        // 如果正在初始化则抛出异常
        throw new IllegalStateException("getReadableDatabase called recursively");
    }
    // 开始实例化数据库mDatabase
    try {
        // 注意这里是调用了getWritableDatabase()方法
        return getWritableDatabase();
    } catch (SQLiteException e) {
        if (mName == null)
            throw e; // Can't open a temp database read-only!
        Log.e(TAG, "Couldn't open " + mName + " for writing (will try read-only):", e);
    }
    // 如果无法以可读写模式打开数据库 则以只读方式打开
    SQLiteDatabase db = null;
    try {
        mIsInitializing = true;
        String path = mContext.getDatabasePath(mName).getPath();// 获取数据库路径
        // 以只读方式打开数据库
        db = SQLiteDatabase.openDatabase(path, mFactory, SQLiteDatabase.OPEN_READONLY);
        if (db.getVersion() != mNewVersion) {
            throw new SQLiteException("Can't upgrade read-only database from version " + db.getVersion() + " to "
                    + mNewVersion + ": " + path);
        }
        onOpen(db);
        Log.w(TAG, "Opened " + mName + " in read-only mode");
        mDatabase = db;// 为mDatabase指定新打开的数据库
        return mDatabase;// 返回打开的数据库
    } finally {
        mIsInitializing = false;
        if (db != null && db != mDatabase)
            db.close();
    }
}

public synchronized SQLiteDatabase getWritableDatabase() {
    if (mDatabase != null && mDatabase.isOpen() && !mDatabase.isReadOnly()) {
        // 如果mDatabase不为空已打开并且不是只读模式 则返回该实例
        return mDatabase;
    }
    if (mIsInitializing) {
        throw new IllegalStateException("getWritableDatabase called recursively");
    }
    // If we have a read-only database open, someone could be using it
    // (though they shouldn't), which would cause a lock to be held on
    // the file, and our attempts to open the database read-write would
    // fail waiting for the file lock. To prevent that, we acquire the
    // lock on the read-only database, which shuts out other users.
    boolean success = false;
    SQLiteDatabase db = null;
    // 如果mDatabase不为空则加锁 阻止其他的操作
    if (mDatabase != null)
        mDatabase.lock();
    try {
        mIsInitializing = true;
        if (mName == null) {
            db = SQLiteDatabase.create(null);
        } else {
            // 打开或创建数据库
            db = mContext.openOrCreateDatabase(mName, 0, mFactory);
        }
        // 获取数据库版本(如果刚创建的数据库,版本为0)
        int version = db.getVersion();
        // 比较版本(我们代码中的版本mNewVersion为1)
        if (version != mNewVersion) {
            db.beginTransaction();// 开始事务
            try {
                if (version == 0) {
                    // 执行我们的onCreate方法
                    onCreate(db);
                } else {
                    // 如果我们应用升级了mNewVersion为2,而原版本为1则执行onUpgrade方法
                    onUpgrade(db, version, mNewVersion);
                }
                db.setVersion(mNewVersion);// 设置最新版本
                db.setTransactionSuccessful();// 设置事务成功
            } finally {
                db.endTransaction();// 结束事务
            }
        }
        onOpen(db);
        success = true;
        return db;// 返回可读写模式的数据库实例
    } finally {
        mIsInitializing = false;
        if (success) {
            // 打开成功
            if (mDatabase != null) {
                // 如果mDatabase有值则先关闭
                try {
                    mDatabase.close();
                } catch (Exception e) {
                }
                mDatabase.unlock();// 解锁
            }
            mDatabase = db;// 赋值给mDatabase
        } else {
            // 打开失败的情况：解锁、关闭
            if (mDatabase != null)
                mDatabase.unlock();
            if (db != null)
                db.close();
        }
    }
}

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent">
    <Button android:layout_width="fill_parent" android:layout_height="wrap_content" android:text="add" android:onClick="add"/>
    <Button android:layout_width="fill_parent" android:layout_height="wrap_content" android:text="update" android:onClick="update"/>
    <Button android:layout_width="fill_parent" android:layout_height="wrap_content" android:text="delete" android:onClick="delete"/>
    <Button android:layout_width="fill_parent" android:layout_height="wrap_content" android:text="query" android:onClick="query"/>
    <Button android:layout_width="fill_parent" android:layout_height="wrap_content" android:text="queryTheCursor" android:onClick="queryTheCursor"/>
    <ListView android:id="@+id/listView" android:layout_width="fill_parent" android:layout_height="wrap_content"/>
</LinearLayout>

package com.scott.db;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import android.app.Activity;
import android.database.Cursor;
import android.database.CursorWrapper;
import android.os.Bundle;
import android.view.View;
import android.widget.ListView;
import android.widget.SimpleAdapter;
import android.widget.SimpleCursorAdapter;
public class MainActivity extends Activity {
    private DBManager mgr;
    private ListView listView;
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        listView = (ListView) findViewById(R.id.listView);
        //初始化DBManager
        mgr = new DBManager(this);
    }
    @Override
    protected void onDestroy() {
        super.onDestroy();
        //应用的最后一个Activity关闭时应释放DB
        mgr.closeDB();
    }
    public void add(View view) {
        ArrayList<Person> persons = new ArrayList<Person>();
        Person person1 = new Person("Ella", 22, "lively girl");
        Person person2 = new Person("Jenny", 22, "beautiful girl");
        Person person3 = new Person("Jessica", 23, "sexy girl");
        Person person4 = new Person("Kelly", 23, "hot baby");
        Person person5 = new Person("Jane", 25, "a pretty woman");
        persons.add(person1);
        persons.add(person2);
        persons.add(person3);
        persons.add(person4);
        persons.add(person5);
        mgr.add(persons);
    }
    public void update(View view) {
        Person person = new Person();
        person.name = "Jane";
        person.age = 30;
        mgr.updateAge(person);
    }
    public void delete(View view) {
        Person person = new Person();
        person.age = 30;
        mgr.deleteOldPerson(person);
    }
    public void query(View view) {
        List<Person> persons = mgr.query();
        ArrayList<Map<String, String>> list = new ArrayList<Map<String, String>>();
        for (Person person : persons) {
            HashMap<String, String> map = new HashMap<String, String>();
            map.put("name", person.name);
            map.put("info", person.age + " years old, " + person.info);
            list.add(map);
        }
        SimpleAdapter adapter = new SimpleAdapter(this, list, android.R.layout.simple_list_item_2,
                    new String[]{"name", "info"}, new int[]{android.R.id.text1, android.R.id.text2});
        listView.setAdapter(adapter);
    }
    public void queryTheCursor(View view) {
        Cursor c = mgr.queryTheCursor();
        startManagingCursor(c); //托付给activity根据自己的生命周期去管理Cursor的生命周期
        CursorWrapper cursorWrapper = new CursorWrapper(c) {
            @Override
            public String getString(int columnIndex) {
                //将简介前加上年龄
                if (getColumnName(columnIndex).equals("info")) {
                    int age = getInt(getColumnIndex("age"));
                    return age + " years old, " + super.getString(columnIndex);
                }
                return super.getString(columnIndex);
            }
        };
        //确保查询结果中有"_id"列
        SimpleCursorAdapter adapter = new SimpleCursorAdapter(this, android.R.layout.simple_list_item_2,
                cursorWrapper, new String[]{"name", "info"}, new int[]{android.R.id.text1, android.R.id.text2});
        ListView listView = (ListView) findViewById(R.id.listView);
        listView.setAdapter(adapter);
    }
}

/**
     * This method allows the activity to take care of managing the given
     * {@link Cursor}'s lifecycle for you based on the activity's lifecycle.
     * That is, when the activity is stopped it will automatically call
     * {@link Cursor#deactivate} on the given Cursor, and when it is later restarted
     * it will call {@link Cursor#requery} for you.  When the activity is
     * destroyed, all managed Cursors will be closed automatically.
     *
     * @param c The Cursor to be managed.
     *
     * @see #managedQuery(android.net.Uri , String[], String, String[], String)
     * @see #stopManagingCursor
     */

CursorWrapper cursorWrapper = new CursorWrapper(c) {
    @Override
    public int getColumnIndexOrThrow(String columnName) throws IllegalArgumentException {
        if (columnName.equals("_id")) {
            return super.getColumnIndex("id");
        }
        return super.getColumnIndexOrThrow(columnName);
    }
};

//读取系统配置信息build.prop类
import android.os.Environment;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Collection;
import java.util.Enumeration;
import java.util.Map.Entry;
import java.util.Properties;
import java.util.Set;
public class BuildProperties {
    private final Properties properties;
    private BuildProperties() throws IOException {
        properties = new Properties();
        properties.load(new FileInputStream(new File(Environment.getRootDirectory(), "build.prop")));
    }
    public boolean containsKey(final Object key) {
        return properties.containsKey(key);
    }
    public boolean containsValue(final Object value) {
        return properties.containsValue(value);
    }
    public Set<Entry<Object, Object>> entrySet() {
        return properties.entrySet();
    }
    public String getProperty(final String name) {
        return properties.getProperty(name);
    }
    public String getProperty(final String name, final String defaultValue) {
        return properties.getProperty(name, defaultValue);
    }
    public boolean isEmpty() {
        return properties.isEmpty();
    }
    public Enumeration<Object> keys() {
        return properties.keys();
    }
    public Set<Object> keySet() {
        return properties.keySet();
    }
    public int size() {
        return properties.size();
    }
    public Collection<Object> values() {
        return properties.values();
    }
    public static BuildProperties newInstance() throws IOException {
        return new BuildProperties();
    }
}
import android.os.Build;
import java.io.IOException;
import java.lang.reflect.Method;
/**
 * 判断系统是不是miui，flyme，emui
 */
public class OSUtils {
    private static final String KEY_EMUI_VERSION_CODE = "ro.build.version.emui";
    private static final String KEY_MIUI_VERSION_CODE = "ro.miui.ui.version.code";
    private static final String KEY_MIUI_VERSION_NAME = "ro.miui.ui.version.name";
    private static final String KEY_MIUI_INTERNAL_STORAGE = "ro.miui.internal.storage";
    private static boolean isPropertiesExist(String... keys) {
        try {
            BuildProperties prop = BuildProperties.newInstance();
            for (String key : keys) {
                String str = prop.getProperty(key);
                if (str == null)
                    return false;
            }
            return true;
        } catch (IOException e) {
            return false;
        }
    }
    public static boolean isEMUI() {
        return isPropertiesExist(KEY_EMUI_VERSION_CODE);
    }
    public static boolean isMIUI() {
        return isPropertiesExist(KEY_MIUI_VERSION_CODE, KEY_MIUI_VERSION_NAME, KEY_MIUI_INTERNAL_STORAGE);
    }
    public static boolean isFlyme() {
        try {
            final Method method = Build.class.getMethod("hasSmartBar");
            return method != null;
        } catch (final Exception e) {
            return false;
        }
    }
}

public class GridAdapter extends BaseAdapter{
List<View> viewList;
...//init opertation
@Override
public int getCount() {
// TODO Auto-generated method stub
return viewList.size();
}
@Override
public Object getItem(int position) {
// TODO Auto-generated method stub
return viewList.get(position);
}
@Override
public long getItemId(int position) {
// TODO Auto-generated method stub
return position;
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
// TODO Auto-generated method stub
return viewList.get(position);
}
public void reorder(){
//reorder view list
}

private HashMap<Object, Integer> mIdMap = new HashMap<Object, Integer>();
private ArrayList<Object> mItems = new ArrayList<Object>();
public ArrayList<Object> getItemList(){
return mItems;
}
@Override
public final boolean hasStableIds() {
return true;
}
/**
* creates stable id for object
* @param item
*/
protected void addStableId(Object item) {
mIdMap.put(item, nextStableId++);
}
/**
* create stable ids for list
* @param items
*/
protected void addAllStableId(List<?> items) {
for (Object item : items) {
addStableId(item);
}
}
/**
* clear stable id map.
* should called when clear adapter data.
*/
protected void clearStableIdMap() {
mIdMap.clear();
}
/**
* remove stable id for item.
* should called on remove data item from adapter.
* @param item
*/
protected void removeStableID(Object item) {
mIdMap.remove(item);
}
private void init(List<?> items) {
addAllStableId(items);
this.mItems.addAll(items);
}
public void set(List<?> items) {
clear();
init(items);
notifyDataSetChanged();
}
public void clear() {
clearStableIdMap();
mItems.clear();
notifyDataSetChanged();
}
public void add(Object item) {
addStableId(item);
mItems.add(item);
notifyDataSetChanged();
}
public void add(int position, Object item) {
addStableId(item);
mItems.add(position, item);
notifyDataSetChanged();
}
public void add(List<?> items) {
addAllStableId(items);
this.mItems.addAll(items);
notifyDataSetChanged();
}
public void remove(Object item) {
mItems.remove(item);
removeStableID(item);
notifyDataSetChanged();
}
public GridViewAdapter(List<?> elements) {
init(elements);
}
@Override
public int getCount() {
return mItems.size();
}
@Override
public Object getItem(int position) {
return mItems.get(position);
}
/**
* get id for position
*
* @param position
* @return
*/
@Override
public final long getItemId(int position) {
if (position < 0 || position >= mIdMap.size()) {
return -1;
}
Object item = getItem(position);
return mIdMap.get(item);
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
View view =(View) getItem(position);
return view;
}
}

java.lang.IllegalArgumentException: parameter must be a descendant of this view
at android.view.ViewGroup.offsetRectBetweenParentAndChild(ViewGroup.java:5353)
at android.view.ViewGroup.offsetDescendantRectToMyCoords(ViewGroup.java:5282)
at android.view.ViewGroup$ViewLocationHolder.init(ViewGroup.java:7755)
at android.view.ViewGroup$ViewLocationHolder.obtain(ViewGroup.java:7689)
at android.view.ViewGroup$ChildListForAccessibility.init(ViewGroup.java:7624)
at android.view.ViewGroup$ChildListForAccessibility.obtain(ViewGroup.java:7592)
at android.view.ViewGroup.addChildrenForAccessibility(ViewGroup.java:1927)
at android.view.ViewGroup.onInitializeAccessibilityNodeInfoInternal(ViewGroup.java:2982)
at android.widget.AdapterView.onInitializeAccessibilityNodeInfoInternal(AdapterView.java:983)
at android.widget.AbsListView.onInitializeAccessibilityNodeInfoInternal(AbsListView.java:1509)
at android.widget.GridView.onInitializeAccessibilityNodeInfoInternal(GridView.java:2361)
at android.view.View.onInitializeAccessibilityNodeInfo(View.java:6151)
at android.view.View.createAccessibilityNodeInfoInternal(View.java:6110)
at android.view.View.createAccessibilityNodeInfo(View.java:6095)
at android.view.accessibility.AccessibilityRecord.setSource(AccessibilityRecord.java:145)
at android.view.accessibility.AccessibilityRecord.setSource(AccessibilityRecord.java:119)
at android.view.View.onInitializeAccessibilityEventInternal(View.java:6047)
at android.widget.AdapterView.onInitializeAccessibilityEventInternal(AdapterView.java:994)
at android.view.View.onInitializeAccessibilityEvent(View.java:6035)
at android.view.View.sendAccessibilityEventUncheckedInternal(View.java:5896)
at android.view.View.sendAccessibilityEventUnchecked(View.java:5881)
at android.view.View$SendViewStateChangedAccessibilityEvent.run(View.java:22468)
at android.os.Handler.handleCallback(Handler.java:743)
at android.os.Handler.dispatchMessage(Handler.java:95)
at android.os.Looper.loop(Looper.java:150)
at android.app.ActivityThread.main(ActivityThread.java:5546)
at java.lang.reflect.Method.invoke(Native Method)
at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:794)
at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:684)

@Override
public void addChildrenForAccessibility(ArrayList<View> outChildren) {
// Explicitly override this to prevent accessibility events being passed down to children
// Those will be handled by the mHostView which lives in the dialog
}

HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Transfer-Encoding: chunked
Connection: keep-alive
Expires: Thu, 19 Nov 1981 08:52:00 GMT
Cache-Control: no-store, no-cache, must-revalidate, post-check=0, pre-check=0
Pragma: no-cache
Content-Encoding: gzip

if (Build.VERSION.SDK_INT >= 19) {
 mWebView.getSettings().setCacheMode(WebSettings.LOAD_CACHE_ELSE_NETWORK);
}

LOAD_CACHE_ONLY: 不使用网络，只读取本地缓存数据
LOAD_DEFAULT: 根据cache-control决定是否从网络上取数据。
LOAD_CACHE_NORMAL: API level 17中已经废弃, 从API level 11开始作用同LOAD_DEFAULT模式
LOAD_NO_CACHE: 不使用缓存，只从网络获取数据.
LOAD_CACHE_ELSE_NETWORK，只要本地有，无论是否过期，或者no-cache，都使用缓存中的数据。