public class Bimp {
    public static int max = 0;
    public static boolean act_bool = true;
    public static List<Bitmap> bmp = new ArrayList<Bitmap>();
    // 图片的存放地址
    public static List<String> drr = new ArrayList<String>();
    // 用于压缩图片
    public static Bitmap revitionImageSize(String path)throws IOException {
        BufferedInputStream in = new BufferedInputStream(new FileInputStream(
                new File(path)));
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeStream(in, null, options);
        in.close();
        int i = 0;
        Bitmap bitmap = null;
        while (true) {
            if ((options.outWidth >> i <= 1000)
                    && (options.outHeight >> i <= 1000)) {
                in = new BufferedInputStream(
                        new FileInputStream(new File(path)));
                options.inSampleSize = (int) Math.pow(2.0D, i);
                options.inJustDecodeBounds = false;
                bitmap = BitmapFactory.decodeStream(in, null, options);
                break;
            }
            i++;
        }
        return bitmap;
    }
}

public class BitmapCache {
    public final String TAG = getClass().getSimpleName();
    public Handle h = new Handle();
    private HashMap<String,SoftReference<Bitmap>> imageCache = new HashMap<String,SoftReference<Bitmap>>();
    public void put(String path,Bitmap bmp) {
        if(!TextUtils.isEmpty(path) && bmp != null) {
            imageCache.put(path, new SoftReference<Bitmap>(bmp));
        }
    }
    public void displayBmp(final ImageView iv, final String thumbPath, final String sourcePath, final ImageCallback call ballback) {
        if (TextUtils.isEmpty(thumbPath) && TextUtils.isEmpty(sourcePath)) {
            Log.e(TAG, "no paths pass in");
            return;
        }
        final String path;
        final boolean isThumbPath;
        if (!TextUtils.isEmpty(thumbPath)) {
            path = thumbPath;
            isThumbPath = true;
        }else if (!TextUtils.isEmpty(sourcePath)) {
            path = sourcePath;
            isThumbPath = false;
        }else {
            return;
        }
        // 缓存中是否有该图片
        if(imageCache.containsKey(path)){
            SoftReference<Bitmap> reference = imageCache.get(path);
            if (bmp != null) {
                if (callback != null) {
                    callback.imageLoad(iv, bmp ,sourcePath);
                }
                iv.setImageBitmap(bmp);
                Log.d(TAG,"hit cache");
                return;
            }
        }
        iv.setImageBitmap(null);
        new Thread() {
            Bitmap thumb;
            public void run(){
                try {
                    if (isThumbPath) {
                        thumb = BitmapFactory.decodeFile(thumbPath);
                        if (thumb == null) {
                            thumb = revitionImageSize(sourcePath);
                        } else {
                            thumb = revitionImageSize(thumbPath);
                        }
                    } catch (Exception e){
                        
                    }
                    if (thumb == null) {
                        thumb = revitionImageSize(sourcePath);
                    }
                    put(path,thumb);
                    if(callback != null){
                        h.post(new Runnable(){
                            @Override
                            public void run() {
                            callback.imageLoad(iv, thumb, sourcePath);
                        }
                    });
                }
            }
        }.strat();
    }

    public Bitmap revitionImageSize(String path) throws IOException {
        BufferedInputStream in = new BufferedInputStream(new FileInputStream(
                new File(path)));
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeStream(in, null, options);
        in.close();
        int i = 0;
        Bitmap bitmap = null;
        while (true) {
            if ((options.outWidth >> i <= 256)
                    && (options.outHeight >> i <= 256)) {
                in = new BufferedInputStream(
                        new FileInputStream(new File(path)));
                options.inSampleSize = (int) Math.pow(2.0D, i);
                options.inJustDecodeBounds = false;
                bitmap = BitmapFactory.decodeStream(in, null, options);
                break;
            }
            i += 1;
        }
        return bitmap;
    }

    public interface ImageCallback {
        public void imageLoad(ImageView imageView, Bitmap bitmap,
                Object... params);
    }
}

public class AlbumHelper {
    private final String TAG = getClass().getSimpleName();
    private Context context;
    private ContentResolver cr;

    // 缩略图列表
    public HashMap<String, String> thumbnailList = new HashMap<String, String>();
    // 专辑列表
    private List<HashMap<String, String>> albumList = new ArrayList<HashMap<String, String>>();
    private HashMap<String, ImageBucket> bucketList = new HashMap<String, ImageBucket>();

    private static AlbumHelper instance;

    private AlbumHelper() {
    }

    public static AlbumHelper getHelper() {
        if (instance == null) {
            instance = new AlbumHelper();
        }
        return instance;
    }

    /**
     * 初始化
     * 
     * @param context
     */
    public void init(Context context) {
        if (this.context == null) {
            this.context = context;
            cr = context.getContentResolver();
        }
    }

    /**
     * 得到缩略图
     */
    private void getThumbnail() {
        String[] projection = { Thumbnails._ID, Thumbnails.IMAGE_ID,
                Thumbnails.DATA };
        Cursor cursor = cr.query(Thumbnails.EXTERNAL_CONTENT_URI, projection,
                null, null, null);
        getThumbnailColumnData(cursor);
    }

    /**
     * 从数据库中得到缩略图
     * 
     * @param cur
     */
    private void getThumbnailColumnData(Cursor cur) {
        if (cur.moveToFirst()) {
            int _id;
            int image_id;
            String image_path;
            int _idColumn = cur.getColumnIndex(Thumbnails._ID);
            int image_idColumn = cur.getColumnIndex(Thumbnails.IMAGE_ID);
            int dataColumn = cur.getColumnIndex(Thumbnails.DATA);

            do {
                _id = cur.getInt(_idColumn);
                image_id = cur.getInt(image_idColumn);
                image_path = cur.getString(dataColumn);
                thumbnailList.put("" + image_id, image_path);
            } while (cur.moveToNext());
        }
    }

    /**
     * 得到原图
     */
    private void getAlbum() {
        String[] projection = { Albums._ID, Albums.ALBUM, Albums.ALBUM_ART,
                Albums.ALBUM_KEY, Albums.ARTIST, Albums.NUMBER_OF_SONGS };
        Cursor cursor = cr.query(Albums.EXTERNAL_CONTENT_URI, projection, null,
                null, null);
        getAlbumColumnData(cursor);

    }

    /**
     * 从本地数据库中得到原图
     * 
     * @param cur
     */
    private void getAlbumColumnData(Cursor cur) {
        if (cur.moveToFirst()) {
            int _id;
            String album;
            String albumArt;
            String albumKey;
            String artist;
            int numOfSongs;

            int _idColumn = cur.getColumnIndex(Albums._ID);
            int albumColumn = cur.getColumnIndex(Albums.ALBUM);
            int albumArtColumn = cur.getColumnIndex(Albums.ALBUM_ART);
            int albumKeyColumn = cur.getColumnIndex(Albums.ALBUM_KEY);
            int artistColumn = cur.getColumnIndex(Albums.ARTIST);
            int numOfSongsColumn = cur.getColumnIndex(Albums.NUMBER_OF_SONGS);

            do {
                _id = cur.getInt(_idColumn);
                album = cur.getString(albumColumn);
                albumArt = cur.getString(albumArtColumn);
                albumKey = cur.getString(albumKeyColumn);
                artist = cur.getString(artistColumn);
                numOfSongs = cur.getInt(numOfSongsColumn);

                Log.i(TAG, _id + " album:" + album + " albumArt:" + albumArt
                        + "albumKey: " + albumKey + " artist: " + artist
                        + " numOfSongs: " + numOfSongs + "---");
                HashMap<String, String> hash = new HashMap<String, String>();
                hash.put("_id", _id + "");
                hash.put("album", album);
                hash.put("albumArt", albumArt);
                hash.put("albumKey", albumKey);
                hash.put("artist", artist);
                hash.put("numOfSongs", numOfSongs + "");
                albumList.add(hash);
            } while (cur.moveToNext());
        }
    }

    /**
     * 是否创建了图片集
     */
    private boolean hasBuildImagesBucketList = false;

    /**
     * 得到图片集
     */
    private void buildImagesBucketList() {
        long startTime = System.currentTimeMillis();

        // 构造缩略图索引
        getThumbnail();

        // 构造相册索引
        String columns[] = new String[] { Media._ID, Media.BUCKET_ID,
                Media.PICASA_ID, Media.DATA, Media.DISPLAY_NAME, Media.TITLE,
                Media.SIZE, Media.BUCKET_DISPLAY_NAME };
        // 得到一个游标
        Cursor cur = cr.query(Media.EXTERNAL_CONTENT_URI, columns, null, null,
                null);
        if (cur.moveToFirst()) {
            // 获取指定列的索引
            int photoIDIndex = cur.getColumnIndexOrThrow(Media._ID);
            int photoPathIndex = cur.getColumnIndexOrThrow(Media.DATA);
            int photoNameIndex = cur.getColumnIndexOrThrow(Media.DISPLAY_NAME);
            int photoTitleIndex = cur.getColumnIndexOrThrow(Media.TITLE);
            int photoSizeIndex = cur.getColumnIndexOrThrow(Media.SIZE);
            int bucketDisplayNameIndex = cur
                    .getColumnIndexOrThrow(Media.BUCKET_DISPLAY_NAME);
            int bucketIdIndex = cur.getColumnIndexOrThrow(Media.BUCKET_ID);
            int picasaIdIndex = cur.getColumnIndexOrThrow(Media.PICASA_ID);
            // 获取图片总数
            int totalNum = cur.getCount();

            do {
                String _id = cur.getString(photoIDIndex);
                String name = cur.getString(photoNameIndex);
                String path = cur.getString(photoPathIndex);
                String title = cur.getString(photoTitleIndex);
                String size = cur.getString(photoSizeIndex);
                String bucketName = cur.getString(bucketDisplayNameIndex);
                String bucketId = cur.getString(bucketIdIndex);
                String picasaId = cur.getString(picasaIdIndex);

                Log.i(TAG, _id + ", bucketId: " + bucketId + ", picasaId: "
                        + picasaId + " name:" + name + " path:" + path
                        + " title: " + title + " size: " + size + " bucket: "
                        + bucketName + "---");

                ImageBucket bucket = bucketList.get(bucketId);
                if (bucket == null) {
                    bucket = new ImageBucket();
                    bucketList.put(bucketId, bucket);
                    bucket.imageList = new ArrayList<ImageItem>();
                    bucket.bucketName = bucketName;
                }
                bucket.count++;
                ImageItem imageItem = new ImageItem();
                imageItem.imageId = _id;
                imageItem.imagePath = path;
                imageItem.thumbnailPath = thumbnailList.get(_id);
                bucket.imageList.add(imageItem);

            } while (cur.moveToNext());
        }
        // Interator为迭代器，Entry为Map接口
        // 遍历所有图片
        Iterator<Entry<String, ImageBucket>> itr = bucketList.entrySet()
                .iterator();
        while (itr.hasNext()) {
            Map.Entry<String, ImageBucket> entry = (Map.Entry<String, ImageBucket>) itr
                    .next();
            ImageBucket bucket = entry.getValue();
            Log.d(TAG, entry.getKey() + ", " + bucket.bucketName + ", "
                    + bucket.count + " ---------- ");
            for (int i = 0; i < bucket.imageList.size(); ++i) {
                ImageItem image = bucket.imageList.get(i);
                Log.d(TAG, "----- " + image.imageId + ", " + image.imagePath
                        + ", " + image.thumbnailPath);
            }
        }
        hasBuildImagesBucketList = true;
        long endTime = System.currentTimeMillis();
        Log.d(TAG, "use time: " + (endTime - startTime) + " ms");
    }

    /**
     * 得到图片集
     * 
     * @param refresh
     * @return
     */
    public List<ImageBucket> getImagesBucketList(boolean refresh) {
        if (refresh || (!refresh && !hasBuildImagesBucketList)) {
            buildImagesBucketList();
        }
        List<ImageBucket> tmpList = new ArrayList<ImageBucket>();
        Iterator<Entry<String, ImageBucket>> itr = bucketList.entrySet()
                .iterator();
        while (itr.hasNext()) {
            Map.Entry<String, ImageBucket> entry = (Map.Entry<String, ImageBucket>) itr
                    .next();
            tmpList.add(entry.getValue());
        }
        return tmpList;
    }

    /**
     * 根据图片的_ID得到原始图像路径
     * 
     * @param image_id
     * @return
     */
    public String getOriginalImagePath(String image_id) {
        String path = null;
        Log.i(TAG, "---(^o^)----" + image_id);
        String[] projection = { Media._ID, Media.DATA };
        Cursor cursor = cr.query(Media.EXTERNAL_CONTENT_URI, projection,
                Media._ID + "=" + image_id, null, null);
        if (cursor != null) {
            cursor.moveToFirst();
            path = cursor.getString(cursor.getColumnIndex(Media.DATA));
        }
        return path;
    }
}

public class Column {
	// 约束
	public static enum Constraint {
		UNIQUE("UNIQUE"), NOT("NOT"), NULL("NULL"), CHECK("CHECK"), FOREIGN_KEY(
				"FOREIGN KEY"), PRIMARY_KYE("PRIMARY KEY");
		private String value;

		private Constraint(String value) {
			this.value = value;
		}

		@Override
		public String toString() {
			return value;
		}
	}

	// 数据类型
	public static enum DataType {
		NULL, INTEGER, REAL, TEXT, BLOB
	}

	private String mColumnName;
	private Constraint mConstraint;
	private DataType mDataType;

	public Column(String columnName, Constraint constraint, DataType dataType) {
		mColumnName = columnName;
		mConstraint = constraint;
		mDataType = dataType;
	}

	public String getColumnName() {
		return mColumnName;
	}

	public Constraint getConstraint() {
		return mConstraint;
	}

	public DataType getDataType() {
		return mDataType;
	}
}

public class SQLiteTable {
	String mTableName;
	ArrayList<Column> mColumnsDefinitions = new ArrayList<Column>();

	public String getTableName() {
		return mTableName;
	}

	// 自动添加主键_ID
	public SQLiteTable(String tableName) {
		mTableName = tableName;
		mColumnsDefinitions.add(new Column(BaseColumns._ID,
				Column.Constraint.PRIMARY_KYE, Column.DataType.INTEGER));
	}

	public SQLiteTable addColumn(Column columnsDefinition) {
		mColumnsDefinitions.add(columnsDefinition);
		return this;
	}

	public SQLiteTable addColumn(String columnName, Column.DataType dataType) {
		mColumnsDefinitions.add(new Column(columnName, null, dataType));
		return this;
	}

	public SQLiteTable addColumn(String columnName,
			Column.Constraint constraint, Column.DataType dataType) {
		mColumnsDefinitions.add(new Column(columnName, constraint, dataType));
		return this;
	}

	// 在SQLite中创建本表
	public void create(SQLiteDatabase db) {
		String formatter = " %s";
		StringBuilder stringBuilder = new StringBuilder();
		stringBuilder.append("CREATE TABLE IF NOT EXISTS ");
		stringBuilder.append(mTableName);
		stringBuilder.append("(");
		int columnCount = mColumnsDefinitions.size();
		int index = 0;
		for (Column columnsDefinition : mColumnsDefinitions) {
			stringBuilder.append(columnsDefinition.getColumnName()).append(
					String.format(formatter, columnsDefinition.getDataType()
							.name()));
			Column.Constraint constraint = columnsDefinition.getConstraint();

			if (constraint != null) {
				stringBuilder.append(String.format(formatter,
						constraint.toString()));
			}
			if (index < columnCount - 1) {
				stringBuilder.append(",");
			}
			index++;
		}
		stringBuilder.append(");");
		db.execSQL(stringBuilder.toString());
	}

	// 在SQLite中删除本表
	public void delete(final SQLiteDatabase db) {
		db.execSQL("DROP TABLE IF EXISTS " + mTableName);
	}
}

public abstract class BaseDataHelper {
	private Context mContext;

	public BaseDataHelper(Context context) {
		mContext = context;
	}

	public Context getContext() {
		return mContext;
	}

	protected abstract Uri getContentUri();

	public void notifyChange() {
		mContext.getContentResolver().notifyChange(getContentUri(), null);
	}

	protected final Cursor query(Uri uri, String[] projection,
			String selection, String[] selectionArgs, String sortOrder) {
		return mContext.getContentResolver().query(uri, projection, selection,
				selectionArgs, sortOrder);
	}

	protected final Cursor query(String[] projection, String selection,
			String[] selectionArgs, String sortOrder) {
		return mContext.getContentResolver().query(getContentUri(), projection,
				selection, selectionArgs, sortOrder);
	}

	protected final Uri insert(ContentValues values) {
		return mContext.getContentResolver().insert(getContentUri(), values);
	}

	protected final int bulkInsert(ContentValues[] values) {
		return mContext.getContentResolver()
				.bulkInsert(getContentUri(), values);
	}

	protected final int update(ContentValues values, String where,
			String[] whereArgs) {
		return mContext.getContentResolver().update(getContentUri(), values,
				where, whereArgs);
	}

	protected final int delete(Uri uri, String selection, String[] selectionArgs) {
		return mContext.getContentResolver().delete(getContentUri(), selection,
				selectionArgs);
	}

	protected final Cursor getList(String[] projection, String selection,
			String[] selectionArgs, String sortOrder) {
		return mContext.getContentResolver().query(getContentUri(), projection,
				selection, selectionArgs, sortOrder);
	}

	public CursorLoader getCursorLoader(Context context) {
		return getCursorLoader(context, null, null, null, null);
	}

	protected final CursorLoader getCursorLoader(Context context,
			String[] projection, String selection, String[] selectionArgs,
			String sortOrder) {
		return new CursorLoader(context, getContentUri(), projection,
				selection, selectionArgs, sortOrder);
	}
}

UriMathcer matcher = new UriMatcher(UriMatcher.NO_MATCH);

matcher.addURI("com.zoe.blog","people",PEOPLE);
matcher.addURI("com.zoe.blog", "person/# ", PEOPLE_ID); 

Uri uri = Uri.parse("content://" + "com.zoe.blog" + "/people");
int match = matcher.match(uri);
switch(match)
{
    case PEOPLE:
        return "vnd.android.cursor.dir/people";
    case PEOPLE_ID:
        return "vnd.android.cursor.item/people";
    default:
        return null;
}