AsyncImgDown.java

package com.bigdo.app;

import java.io.File;
import java.io.FileOutputStream;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;

import org.json.JSONException;
import org.json.JSONObject;

import com.bigdo.common.RConfig;
import com.bigdo.common.RState;
import com.bigdo.util.Base64;
import com.bigdo.util.MD5;
import com.bigdo.util.WSCheck;
import com.bigdo.util.WSHelper;
import com.bigdo.util.WSResult;

import android.annotation.SuppressLint;
import android.content.ContentResolver;
import android.graphics.Bitmap;
import android.net.Uri;
import android.os.Environment;
import android.os.Handler;
import android.os.Message;
import android.provider.MediaStore;
import android.provider.MediaStore.Images.Media;
import android.util.Log;
import android.widget.ImageView;
import android.widget.ImageView.ScaleType;

public abstract class AsyncImgDown {
	private boolean isExist = true, isRun = false;

	private HashMap<String, AsyncImgDownInfo> imgRequest;

	private String curr_request = "";

	protected BaseActivity a;
	protected ContentResolver cr;
	private String _sdDir = "";

	public AsyncImgDown(BaseActivity a) {
		String status = Environment.getExternalStorageState();
		if (!status.equals(Environment.MEDIA_MOUNTED)) {
			isExist = false;
		} else {
			_sdDir = Environment.getExternalStorageDirectory() + "";
		}
		imgRequest = new HashMap<String, AsyncImgDownInfo>();
		this.a = a;
		cr = a.getContentResolver();

	}

	protected String sdDir(int requestCode) {
		if (_sdDir != null && !_sdDir.equals("")) {
			return _sdDir + imgDir(requestCode);
		}
		return "";
	}

	protected boolean loadImg(ImageView img, String path, String error,
			int requestCode) {
		if (isExist) {
			if (path != null && !path.equals("")) {
				File f = new File(path);
				if (f.exists()) {
					try {
						img.setImageBitmap(null);
						img.setDrawingCacheEnabled(false);
						img.setDrawingCacheEnabled(true);
						Uri u = Uri.fromFile(f);
						Bitmap bmp = MediaStore.Images.Media.getBitmap(cr, u);
						// Bitmap bmp = Media.getBitmap(cr, u);
						img.setImageBitmap(bmp);//
						if ("l".equals(img.getTag())) {
							img.setScaleType(ScaleType.CENTER_CROP);
						} else {
							if ("CENTER".equals(img.getTag())) {
								img.setScaleType(ScaleType.CENTER);
							} else {
								img.setScaleType(ScaleType.CENTER_CROP);
							}
						}
						return true;
					} catch (Exception e) {
					}
				}
			}
			if ("no_exist_for_service".equals(error)) {
				img.setScaleType(ScaleType.CENTER);
				// img.setImageResource(R.drawable.video_img_failure);
				int imgf = imgFailure(requestCode);
				if (imgf > 0) {
					img.setImageResource(imgf);
				} else {
					img.setImageBitmap(null);
				}
				return true;
			} else {
				img.setScaleType(ScaleType.CENTER);
				// img.setImageResource(R.drawable.video_img_loading);
				int imgl = imgLoading(requestCode);
				if (imgl > 0) {
					img.setImageResource(imgl);
				} else {
					img.setImageBitmap(null);
				}
			}
			return false;
		} else {
			img.setScaleType(ScaleType.CENTER);
			// img.setImageResource(R.drawable.video_img_failure);
			int imgf = imgFailure(requestCode);
			if (imgf > 0) {
				img.setImageResource(imgf);
			} else {
				img.setImageBitmap(null);
			}
			return true;
		}

	}

	public String startGetImg(AsyncImgDownInfo data) {
		try {
			if (isExist) {
				if (data != null && data.downName != null
						&& !data.downName.equals("") && data.cacheName != null
						&& !data.cacheName.equals("")) {
					// String img_name = handleImgName(data.cacheName);
					if (!imgRequest.containsKey(data.cacheName)) {
						imgRequest.put(data.cacheName, data);
						if (doStartGetImg()) {
							return "geting_for_service";
						}
					} else {
						return "geting_for_service";
					}
				}
			}
		} catch (Exception e) {
		}
		return "no_exist_for_service";
	}

	private boolean doStartGetImg() {
		if (!isRun && isExist) {
			if (imgRequest != null && imgRequest.size() > 0) {
				isRun = true;
				AsyncImgDownInfo val = null;
				JSONObject jparams = null;
				boolean error = false, isBreak = true;
				while (imgRequest != null && imgRequest.size() > 0) {
					Iterator<Entry<String, AsyncImgDownInfo>> iter = imgRequest
							.entrySet().iterator();
					error = false;
					isBreak = true;
					while (iter.hasNext()) {
						Entry<String, AsyncImgDownInfo> entry = iter.next();
						val = entry.getValue();
						curr_request = entry.getKey();
						try {
							jparams = new JSONObject();
							jparams.put("pos", val.pos);
							jparams.put("img", val.downName);
							jparams.put("param", val.param);
						} catch (JSONException e) {
							jparams = null;
							error = true;
						}
						if (error || val == null || curr_request == null
								|| curr_request.equals("")) {
							imgRequest.remove(curr_request);
							isBreak = false;
							break;
						}
						isBreak = true;
						break;
					}
					if (isBreak) {
						break;
					}
				}
				if (jparams != null) {
					String u = RConfig.getImg(this.a);
					String data = jparams.toString();
					new WSHelper(this.a, "", false, img_handler, u, null,
							WSHelper.getStringEntity(data), 0, val.pos, 0, 0,
							WSHelper.POST).start();
					Log.e("doStartGetImg", u);
					Log.e("doStartGetImg_data", data);
					u = null;
					data = null;
					jparams = null;
					return true;
				}
			}
			return false;
		} else {
			return true;
		}

	}

	public void updateVideoImg(WSResult result, int pos) {
		String path = "";
		AsyncImgDownInfo info = null;
		if (isExist) {
			StringBuilder outMsg = new StringBuilder();
			JSONObject jresult = WSCheck.Json(this.a, result, outMsg);
			try {
				info = imgRequest.get(curr_request);
				if (jresult != null) {
					String data = "";
					data = jresult.getString("data");
					if (data != null && !data.equals("")) {
						byte[] imgData = Base64.decode(data, Base64.DEFAULT);
						if (imgData != null && imgData.length > 0) {
							try {
								File tdf = new File(sdDir(info.requestCode));
								if (!tdf.exists()) {
									tdf.mkdirs();
								}
								String fn = curr_request + ".r";
								File f = new File(tdf, fn);
								if (f.exists()) {
									f.delete();
								}
								FileOutputStream fosto = new FileOutputStream(f);
								fosto.write(imgData, 0, imgData.length); // 将内容写到新文件当中
								fosto.flush();
								fosto.close();
								imgData = null;
								path = sdDir(info.requestCode) + fn;
							} catch (Exception e) {
							}
						}
					}
				}
			} catch (Exception e) {
			}
		}
		finishGetImg(path, info);
		try {
			if (imgRequest.size() > 0) {
				imgRequest.remove(curr_request);
			}
		} catch (Exception e) {
		}
		curr_request = "";
		isRun = false;
		doStartGetImg();
	}

	protected String handleImgName(String img_name) {
		if (img_name != null && !img_name.equals("")) {
			img_name = MD5.encode(img_name);
		}
		return img_name;
	}

	@SuppressLint("HandlerLeak")
	protected Handler img_handler = new Handler() {
		public void handleMessage(Message msg) {
			super.handleMessage(msg);
			if (msg.arg1 == RState.WSCall) {
				WSResult result = (WSResult) msg.getData().getParcelable(
						WSResult.ResultKey);
				updateVideoImg(result, result.RequestCode2);
			}
		}
	};

	protected abstract void finishGetImg(String path,
			final AsyncImgDownInfo info);

	protected abstract String imgDir(int requestCode);

	protected abstract int imgFailure(int requestCode);

	protected abstract int imgLoading(int requestCode);
}