Android TV开发--实现屏保图片云端可配置

功能描述：

 在TV上，出厂时会默认配置一组屏保图片，用作屏保初期展示。
 但作为运营的工具之一，当然会希望屏保图片可以在云端配置，若未配置则采用系统默  认图片。
 若配置了一组新的图片，则需要下载到本地，在下次启动屏保时用来展示。

功能明确点：

1.屏保check时机：屏保启动
2.新屏保使用时机：屏保启动
3.屏保从云端下载图片后保存路径：
../files/screenPic/pathA/
../files/screenPic/pathB/
此处采用A/B目录来保存，便于在使用一组的同时下载另一组，类似于A/B系统
4.旧目录中图片删除时机：屏保退出时，发现刚进入时screenPath与退出时screenPath不一致（表示已同步成功，则删除之前使用目录中的图片）
5.支持设置屏保同步百分比阈值，大于该阈值则认为同步成功（比如10张成功8张以上），下次启动需要使用新屏保。 使用该目录屏保后，check云端时间与本地时间一致且发现上次未完全同步成功，则继续同步剩余未成功的图片。

图片同步流程图：

流程提示：

1.在屏保进入时，check下载信息，根据云端、上次同步时间戳
2.在网络请求成功回调中开始图片同步
3.同步时需要判断图片是否已经在本地存在，若存在则copy，否则下载
4.整理出copy list和download list
5.下载包括MD5 check 机制和retry重试3次机制
6.当copy完毕且download完毕，统计成功率是否大于阈值
7.大于阈值值存屏保新路径，若达到100%则保存完整下载FullDLFlag

 补充：此处使用Json，来保存图片下载信息、图片copy，屏保按照云端配置的顺序显示，所以需要使用一种数据结构来存储相关信息，这里使用Json，通过更新Json信息达到，下载、使用图片的目的。

  

  下面是代码说明部分

    1.触发屏保图片同步入口

   

/**
 * picture whether need to update
 * this class call downloadhelper to download picture
 * @author WMB
 */
public class PicCheckHelper {
	private static PicCheckHelper instance = null;
	private BaseTimer mTimer = null;
	private static final int REQUESTINTERVAL = 60 * 1000; // 2 * 60 * 60 * 1000
	
	public static PicCheckHelper getInstance(){
		if(null == instance){
			instance = new PicCheckHelper();
		}
		return instance;
	}
	
	/**
	 * start 2h Timer
	 */
	public void start(){
		if(null == mTimer){
			mTimer = new BaseTimer();
		}
		mTimer.startInterval(REQUESTINTERVAL, mTimerCallback);
	}
	
	/**
	 * close Timer
	 */
	public void close(){
		if(null != mTimer){
			mTimer.killTimer();
		}
	}
	
	/**
	 * check right now
	 */
	public void checkNow(){
		checkPic();
	}
	
	/**
	 * check picture whether need to update by cloud request
	 */
	private void checkPic() {
		GeneralHttpHelper.getInstance().requestScreenPicUpdate(mHttpCallback);
	}	
	
	/**
	 * 定时器回调接口
	 */
	private TimerCallBack mTimerCallback = new TimerCallBack() {
		
		@Override
		public void callback() {
			checkPic();
		}
	};
	
	private HttpCallback mHttpCallback = new HttpCallback() {
		
		@Override
		public void onState(HTTP_STATE state) {
			switch (state) {
			case STATE_SUCCESS:
				syncPic();				
				break;

			default:
				break;
			}	
		}

	};
	
	/**
	 * 执行图片同步入口
	 */
	private void syncPic() {
		PicSyncHelper.getInstance().syncPicture();	
	}
}

外部调用checkNow,立刻去云端检查是否有新的屏保，在网络请求成功回调中执行syncPic方法开始同步逻辑。

2.屏保同步解析类（解析云端请求信息）

/**
 * 屏保同步解析类
 */
public class ScreenSyncParser extends BaseParser {

	@Override
	public void run() {
		parserScreenData();
	}

	private void parserScreenData() {
		try {
			JSONObject jsonObj = new JSONObject(mParseData);
			if(jsonObj.optInt("status") < 0){
				sendMessage(HTTP_STATE.STATE_ERROR);
				LogHelper.releaseLog(PicCons.SCREEN_TAG, "ScreenSyncParser -- http request status < 0");
				return;
			}
			JSONObject data = jsonObj.optJSONObject("data");
			String timestamp = data.optString("updatetimes");
			LogHelper.releaseLog(PicCons.SCREEN_TAG, "ScreenSyncParser -- parserScreenData cloudtimestamp : "+ timestamp);
			Utils.setCloudTimestamp(timestamp);
			boolean needsync = compareTimeStamp(timestamp);// 比较云端时间戳与本地时间戳
			if(needsync){ // 云端时间新，则保存云端Json信息，为下载做准备（另一种情况：时间戳相等，上次下载80%,则保持之前存的Json不变，继续下载未成功的部分，后面会提到）
				JSONArray jsonData = data.optJSONArray("pics");
				if(null == jsonData || jsonData.length() == 0){
					return;
				}
				INFO_DL item = null;
				ArrayList<INFO_DL> resultList = new ArrayList<INFO_DL>();
				for (int i = 0; i < jsonData.length(); i++) {
					item = new INFO_DL();
					JSONObject jsonItem = jsonData.optJSONObject(i);
					item.dlIndex = i;
					item.md5 = jsonItem.optString("fileHash");
					item.url = jsonItem.optString("url");
					item.fileType = Utils.getPicTypeByUrl(item.url);
					resultList.add(item);				
				}
				LogHelper.releaseLog(PicCons.SCREEN_TAG, "ScreenSyncParser -- parserScreenData needsync is true ,resultList size: "+resultList.size());
				saveDLJson(resultList); // 存到文件中，为下载做准备
				Utils.setFullDLFlag(true);// 若云端时间新，则默认上次同步已经完全成功，开始新的同步
			}
			else{
				LogHelper.releaseLog(PicCons.SCREEN_TAG, "ScreenSyncParser -- parserScreenData needsync is false don't need save DLJson");
			}	
			sendMessage(HTTP_STATE.STATE_SUCCESS);
		} catch (Exception e) {
			sendMessage(HTTP_STATE.STATE_ERROR);
			LogHelper.releaseLog(PicCons.SCREEN_TAG, "ScreenSyncParser -- http request error!");
		}
		
	}
	
	/**
	 * compare cloud and local timestamp
	 * @param cloudTimestamp
	 * @return true: cloud > local ,false:otherwise
	 */
	public boolean compareTimeStamp(String cloudTimestamp){
		String localTimestamp = Utils.getScreenTimestamp();
		if(TextUtils.isEmpty(localTimestamp)){
			LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicSyncHelper -- compareTimeStamp localTimestamp is empty, need to sync");
			return true;
		}
		if(TextUtils.isEmpty(cloudTimestamp)){
			LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicSyncHelper -- compareTimeStamp cloudTimestamp is empty, don't need to sync");
			return false;
		}
		try {
			long localTime = Long.parseLong(localTimestamp);
			long cloudTime = Long.parseLong(cloudTimestamp);
			LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicSyncHelper -- compareTimeStamp cloudTimestamp is : "+cloudTimestamp+",localTimestamp is: "+localTimestamp);
			return cloudTime > localTime;			
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}
	
	/**
	 * save download json
	 * @param list
	 */
	public void saveDLJson(ArrayList<INFO_DL> list){
		if(null == list){
			LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicSyncHelper -- saveDLJson ArrayList<INFO_DL> is null");
			return;
		}
		JSONArray jsonArray = new JSONArray();
		JSONObject jsonObj = null;
		INFO_DL infoItem = null;
		for (int i = 0; i < list.size(); i++) {
			jsonObj = new JSONObject();
			infoItem = new INFO_DL();
			infoItem = list.get(i);
			try {
				jsonObj.put("md5", infoItem.md5);
				jsonObj.put("url", infoItem.url);
				jsonObj.put("savePath", infoItem.savePath);
				jsonObj.put("DLFlag", infoItem.DLFlag);
				jsonObj.put("dlIndex", infoItem.dlIndex);
				jsonObj.put("reTry", infoItem.reTry);
				jsonObj.put("copyPath", infoItem.copyPath);
				jsonObj.put("fileType", infoItem.fileType);
				jsonArray.put(jsonObj);
			} catch (JSONException e) {
				
				e.printStackTrace();
				LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicSyncHelper -- saveDLJson has an exception");
				return;
			}			
		}
		LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicSyncHelper -- saveDLJson :"+jsonArray.toString());
		Utils.setDLJson(jsonArray.toString());
	}
}

同步帮助类

/**
 * this class is responsible for sync picture include download and copy,
 * @author WMB
 *
 */
public class PicSyncHelper {
	private static PicSyncHelper instance = null;
	private ArrayList<INFO_DL> DLJsonList = new ArrayList<INFO_DL>(); // 同步所用list(DLFlag为false)
	private ArrayList<INFO_DL> AllDLList = new ArrayList<INFO_DL>(); //  所有dlList不区分DLFlag(用于向硬盘中写下载数据)
	private ArrayList<INFO_DL> UsingJsonList = new ArrayList<INFO_DL>(); // 屏保图片展示所用list
	private String picCopyPath = ""; // 图片copy路径
	private boolean isDownloadEnd = false;  // 下载完毕标志位
	private boolean isCopyEnd = false;  // copy完毕标志位
	private String filePath = "";
	public static PicSyncHelper getInstance(){
		if(null == instance){
			instance = new PicSyncHelper();
		}
		return instance;
	}
	private PicSyncHelper(){
		filePath = Common.getContext().getFilesDir().getPath();
	}
	
	private Handler mHandle = new Handler(){

		@Override
		public void handleMessage(Message msg) {
			switch (msg.what) {
			case PicCons.MESSAGE_DL:
			case PicCons.MESSAGE_CP:
				setScreenPath(true);
				break;
			case PicCons.MESSAGE_DL_PARTOK:
				isDownloadEnd = true;
				setScreenPath(false);
				break;
			case PicCons.MESSAGE_CP_PARTOK:
				isCopyEnd = true;
				setScreenPath(false);

			default:
				break;
			}
		}
		
	};
	
	
	
	/**
	 * 执行图片同步逻辑
	 */
	public void syncPicture(){
		isDownloadEnd = false;
		isCopyEnd = false;
		if(DLJsonList == null || DLJsonList.size() <= 0){
			initDLJson(); // 初始化下载List
		}
		if(DLJsonList == null || DLJsonList.size() <= 0){ // 下载List为空，不做处理，退出
			LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicSyncHelper -- syncPicture , DLJsonList is empty ,do nothing ,exist!");
			return;
		}
		String usingJson = Utils.getUsingJson(); // 获取正在使用的Json信息
		Utils.setScreenTimestamp(Utils.getCloudTimestamp()); //  保存本地同步时间戳
		if(TextUtils.isEmpty(usingJson)){ 
			// 全量下载
			LogHelper.releaseLog(PicCons.SCREEN_TAG, "--begin All download , download size is:"+DLJsonList.size());
			new Thread(new PicDownloadManager(DLJsonList, mHandle ,PicCons.MESSAGE_DL)).start();
		}
		else{ // 已存在则copy，不存在则下载
			try {
				JSONArray jsonArray = new JSONArray(usingJson);
				if(null != UsingJsonList && UsingJsonList.size() == 0){
					initUsingJsonList(jsonArray);
				}
				ArrayList<INFO_DL> dlList = new ArrayList<INFO_DL>();
				final ArrayList<INFO_DL> cpList = new ArrayList<INFO_DL>();
				INFO_DL Item = null;
				for (int i = 0; i < DLJsonList.size(); i++) {
					Item = DLJsonList.get(i);
					if(picisExist(Item.md5)){ //加入复制
						if(!TextUtils.isEmpty(picCopyPath)){
							Item.copyPath = picCopyPath;
							Item.savePath = getSavePath(picCopyPath);
							cpList.add(Item);
						}
					}
					else{ // 加入下载
						dlList.add(Item);
					}
					
				}
				if(dlList.size() > 0){
					// 下载
					if(cpList.size() > 0){
						LogHelper.releaseLog(PicCons.SCREEN_TAG, "--begin Part of download , download size is:"+dlList.size());
						new Thread(new PicDownloadManager(dlList,mHandle,PicCons.MESSAGE_DL_PARTOK)).start();
					}
					else{
						LogHelper.releaseLog(PicCons.SCREEN_TAG, "--begin All download ,using json exist, download size is:"+dlList.size());
						new Thread(new PicDownloadManager(dlList,mHandle,PicCons.MESSAGE_DL)).start();
					}
				}
				
				if(cpList.size() > 0){
					// 复制
					if(dlList.size() > 0){
						LogHelper.releaseLog(PicCons.SCREEN_TAG, "--begin Part copy, copy size is:"+cpList.size());
						new Thread(new Runnable() {
							
							@Override
							public void run() {
								copy(cpList, PicCons.MESSAGE_CP_PARTOK);
							}
						}).start();
					}
					else{
						LogHelper.releaseLog(PicCons.SCREEN_TAG, "--begin All copy, copy size is:"+cpList.size());
                         new Thread(new Runnable() {
							
							@Override
							public void run() {
								copy(cpList, PicCons.MESSAGE_CP);
							}
						}).start();		
					}
				}				
			} catch (JSONException e) {
				
				e.printStackTrace();
			}
		}	
	}	
	
	/**
	 * update download json info 
	 * @param index
	 * @param data
	 */
	public void updateDLJson(int index, INFO_DL data){
		if(null == AllDLList || AllDLList.size() == 0){
			String DLJsonStr = Utils.getDLJson();
			try {
				JSONArray DLJsonArr = new JSONArray(DLJsonStr);
				JSONObject updateItem = new JSONObject();
				updateItem.put("md5", data.md5);
				updateItem.put("url", data.url);
				updateItem.put("savePath", data.savePath);
				updateItem.put("DLFlag", data.DLFlag);
				updateItem.put("dlIndex", data.dlIndex);
				updateItem.put("reTry", data.reTry);
				updateItem.put("copyPath", data.copyPath);
				updateItem.put("fileType", data.fileType);
				DLJsonArr.put(index, updateItem);
				LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicSyncHelper -- updateDLJson,DLJsonList is empty ,updata index : "+index+", jsonObj :"+updateItem.toString());
				Utils.setDLJson(DLJsonArr.toString());
			} catch (JSONException e) {
				LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicSyncHelper -- updateDLJson has an Exception");
				e.printStackTrace();
				return;
			}
		}
		else{
			if(index >= 0 && index < AllDLList.size()){
				AllDLList.remove(index);
				AllDLList.add(index, data);
				saveDLJson(AllDLList);
			}
		}	
	}
	
	/**
	 * save download json
	 * @param list
	 */
	public void saveDLJson(ArrayList<INFO_DL> list){
		if(null == list){
			LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicSyncHelper -- saveDLJson ArrayList<INFO_DL> is null");
			return;
		}
		JSONArray jsonArray = new JSONArray();
		JSONObject jsonObj = null;
		INFO_DL infoItem = null;
		for (int i = 0; i < list.size(); i++) {
			jsonObj = new JSONObject();
			infoItem = new INFO_DL();
			infoItem = list.get(i);
			try {
				jsonObj.put("md5", infoItem.md5);
				jsonObj.put("url", infoItem.url);
				jsonObj.put("savePath", infoItem.savePath);
				jsonObj.put("DLFlag", infoItem.DLFlag);
				jsonObj.put("dlIndex", infoItem.dlIndex);
				jsonObj.put("reTry", infoItem.reTry);
				jsonObj.put("copyPath", infoItem.copyPath);
				jsonObj.put("fileType", infoItem.fileType);
				jsonArray.put(jsonObj);
			} catch (JSONException e) {
				
				e.printStackTrace();
				LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicSyncHelper -- saveDLJson has an exception");
				return;
			}			
		}
		DLJsonList = list;
		LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicSyncHelper -- saveDLJson :"+jsonArray.toString());
		Utils.setDLJson(jsonArray.toString());
	}
	
	/**
	 * 获取下载路径，如果上次未下载完全，则还将图片下载到之前使用的目录中
	 * @return DLPath
	 */
	public String getDLPath(){
		boolean isFullDownload = Utils.getFullDLFlag();
		String usingPath = Utils.getScreenPath();
		LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicSyncHelper -- now screenPath is:"+usingPath);
		String DLPath;
		if(TextUtils.isEmpty(usingPath)){
			DLPath = PicCons.SCREEN_PATH_A;
		}
		else{
			if(isFullDownload){
				LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicSyncHelper -- isFUllDownload is true");
				DLPath = PicCons.SCREEN_PATH_A.equals(usingPath)? PicCons.SCREEN_PATH_B : PicCons.SCREEN_PATH_A;
			}
			else{
				LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicSyncHelper -- isFUllDownload is false");
				DLPath = PicCons.SCREEN_PATH_A.equals(usingPath)? PicCons.SCREEN_PATH_A : PicCons.SCREEN_PATH_B;
			}
		}
		LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicSyncHelper -- getDLPath : "+ filePath+DLPath);
		return filePath+DLPath;
	}
	
	/**
	 * 判断图片是否在本地存在
	 * @param md5
	 * @return
	 */
	private boolean picisExist(String md5){
		if(null == UsingJsonList || UsingJsonList.size() <= 0){
			return false;
		}
		INFO_DL jsonItem = null;
		for (int i = 0; i < UsingJsonList.size(); i++) {
			jsonItem = UsingJsonList.get(i);
			if(md5.equals(jsonItem.md5)){
				picCopyPath = jsonItem.savePath;
				return true;
			}
		}					
		return false;
		
	}
	/**
	 * 初始化下载使用Json信息
	 */
	private void initDLJson(){
		String dlStr = Utils.getDLJson();
		if(!TextUtils.isEmpty(dlStr)){
			
			try {
				JSONArray jsonArray = new JSONArray(dlStr);				
				if(null != jsonArray){
					ArrayList<INFO_DL> allDLList = Utils.transJsonToList(jsonArray);
					if(null != allDLList){
						int size = allDLList.size();
						INFO_DL item = null;
						if(size > 0){
							for (int i = 0; i < size; i++) {
								item = allDLList.get(i);
								AllDLList.add(item); 
								if(!item.DLFlag){ // 将下载或copy失败的加进来
									DLJsonList.add(item);
								}
							}
							LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicSyncHelper -- initDLJson success , DLJsonList size:"+DLJsonList.size());
						}
						
					}
					else{
						LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicSyncHelper -- initDLJson allDLList is null, so DLJsonList is empty");
					}
				}
			} catch (Exception e) {
				LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicSyncHelper -- initDLJson has an Exception");
				e.printStackTrace();
			}
			
		}
	}
	
	/**
	 * 初始化屏保图片使用Json信息
	 * @param jsonArray
	 */
	private void initUsingJsonList(JSONArray jsonArray) {
		if(null == jsonArray){
			return;
		}
		UsingJsonList = Utils.transJsonToList(jsonArray);	
	}
	
	/**
	 * 根据图片拷贝路径，获得图片保存路径
	 * @param copyPath 图片拷贝路径
	 * @return 图片保存路径
	 */
	private String getSavePath(String copyPath){
		String usingPath = Utils.getScreenPath();
		LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicSyncHelper -- getScreenPath --"+copyPath);
		String newPath = "";
		if(usingPath.contains(PicCons.SCREEN_PATH_A)){ // 从A到B
			newPath = copyPath.replace(PicCons.SCREEN_PATH_A, PicCons.SCREEN_PATH_B);
		}
		else if(usingPath.contains(PicCons.SCREEN_PATH_B)){ // 从B到A
			newPath = copyPath.replace(PicCons.SCREEN_PATH_B, PicCons.SCREEN_PATH_A);
		}
		LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicSyncHelper -- getCopyFilePath --"+newPath);
		return newPath;
	}
	
	//复制图片，利用管道流提升效率
	private boolean copyAToB(String fileFrom , String fileTo){
		File from = new File(fileFrom);
		if(from.exists()){
			File to = new File(fileTo);
			if(!to.exists()){
				try {
					to.createNewFile();
					LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicSyncHelper -- copyAToB --create New file :" +to.getPath());
				} catch (IOException e) {
					e.printStackTrace();
					LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicSyncHelper -- copyAToB --create file has an Exception");
					return false;
				}
			}
			FileInputStream in = null;
			FileOutputStream out = null;
			FileChannel infc = null;
            FileChannel outfc = null;
			try {
				in = new FileInputStream (from);
				out = new FileOutputStream (to);
				infc = in.getChannel();
				outfc = out.getChannel();
//				int temp = 0;
//				while ((temp=in.read ())!=-1)
//				{
//					out.write (temp);
//				}
				infc.transferTo(0, infc.size(), outfc);
				LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicSyncHelper -- copyAToB success from :"+ fileFrom+", to:"+fileTo);
				return true;
			} catch (Exception e) {
				e.printStackTrace();
				LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicSyncHelper -- copyAToB has an Exception");
				return false;
			} finally {
					try {
						if(null != in){
							in.close();
						}
						if(null != out){
							out.close();
						}
						if(null != infc){
							infc.close();
						}
						if(null != outfc){
							outfc.close();
						}
					} catch (Exception e) {
						e.printStackTrace();
					}
			}
		}
		else{
			LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicSyncHelper -- copyAToB fileFrom:"+fileFrom+" is not exists");
			return false;
		}
		
	}
	
	private void copy(ArrayList<INFO_DL> cpList ,int messageType){
		if(null == cpList){
			return;
		}
		createFolder();
		INFO_DL Item = null;
		for (int i = 0; i < cpList.size(); i++) {
			Item = cpList.get(i);
			boolean copysuccess = copyAToB(Item.copyPath, Item.savePath);
			if(copysuccess){
				if(Utils.MD5Check(Item.savePath, Item.md5)){
					Item.DLFlag = true;
					LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicSyncHelper -- copy file MD5 check success , update Json Item");
					updateDLJson(Item.dlIndex, Item);
				}
			}
			
		}
		mHandle.sendEmptyMessage(messageType);
	}
	
	/**
	 * 复制之前保证，PathA、PathB都存在
	 */
	private void createFolder(){
		File pathA = new File(filePath+PicCons.SCREEN_PATH_A);
		File pathB = new File(filePath+PicCons.SCREEN_PATH_B);
		if(!pathA.exists()){
			pathA.mkdirs();
		}
		if(!pathB.exists()){
			pathB.mkdirs();
		}	
	}
	

	/**
	 * 修改fullDLFlag的值，是否完全下载
	 */
	private void setFullDLFlag(boolean fullDLFlag) {
		Utils.setFullDLFlag(fullDLFlag);
		LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicSyncHelper -- setFullDLFlag: "+fullDLFlag);
	}
	
	/**
	 * 清空DLJsonList信息
	 */
	private void cleanDLJson(){
		if(null != DLJsonList){
			DLJsonList.clear();
		}
	}
	
	/**
	 * 设置screenPath，图片成功数量大于约定上线，则设置，否则不设置
	 * @param setNow 是否直接设置，用于限制下载和copy都完成，则执行该逻辑
	 * @param isDownload 
	 */
	private void setScreenPath(boolean setNow){
		if(!setNow){
			if(!isDownloadEnd || !isCopyEnd){
				return;
			}
		}	
		cleanDLJson();
		String DLJsonStr = Utils.getDLJson();
		int dlSuccessSize = 0;
		float dlTotalSize = 0;
		if(!TextUtils.isEmpty(DLJsonStr)){
			try {
				JSONArray DLJsonArr= new JSONArray(DLJsonStr);
				JSONObject DLJsonItem = null;
				dlTotalSize = DLJsonArr.length();
				for (int i = 0; i < dlTotalSize; i++) {
					DLJsonItem = DLJsonArr.optJSONObject(i);
					boolean dlSuccess = DLJsonItem.optBoolean("DLFlag");
					if(dlSuccess){
						dlSuccessSize++;
					}
				}
				
				if(dlTotalSize > 0){
					float DLSuccessRate = (float) dlSuccessSize / dlTotalSize; 
					LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicSyncHelper --setScreenPath DLSuccessRate is:"+DLSuccessRate);
					if(DLSuccessRate >= PicCons.SHOW_LIMIT){
						String screenPath = getDLPath();
						if(screenPath.contains(PicCons.SCREEN_PATH_A)){
							Utils.setScreenPath(PicCons.SCREEN_PATH_A); // 设置显示目录为A
							LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicSyncHelper --setScreenPath PATH_A");
						}
						else{
							Utils.setScreenPath(PicCons.SCREEN_PATH_B); // 设置显示目录为B
							LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicSyncHelper --setScreenPath PATH_B");
						}						
						Utils.setUsingJson(DLJsonStr);  // 设置使用Json
						LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicSyncHelper -- setUsingJson :"+DLJsonStr);
					}
					if(DLSuccessRate == 1.0f){
						setFullDLFlag(true);
					}
					else{
						setFullDLFlag(false);
					}
				}
				
				
			} catch (Exception e) {
				
			}
		}
		
	}
}

其中主要方法为syncPicture，执行图片同步逻辑，启动线程下载、copy图片，完成后发送消息到Handler，执行setScreenPath方法。

Utils工具类

放置一些工具方法

public class Utils {
	
	public static String getPicTypeByUrl(String url){
		String picType = "";
		if(TextUtils.isEmpty(url)){
			return picType;
		}
		int lastPointIndex = url.lastIndexOf(".");
		if(-1 == lastPointIndex){
			return picType;
		}
		
		return url.substring(lastPointIndex, url.length());
		
	}
	
	public static boolean MD5Check(String filepath, String md5){
		if(TextUtils.isEmpty(filepath) || TextUtils.isEmpty(md5)){
			return false;
		}
		try {
			String fileMd5 = MD5Util.getFileMD5String(new File(filepath));
			return md5.equalsIgnoreCase(fileMd5);
		} catch (IOException e) {
			e.printStackTrace();
		}
		return false;
	}
	
	/**
	 * JSONArray数组转为ArrayList
	 * @param dlFlag
	 * @param jsonArray
	 * @return
	 */
	public static ArrayList<INFO_DL> transJsonToList(JSONArray jsonArray){
		if(null == jsonArray){
			return null;
		}
		ArrayList<INFO_DL> jsonList = new ArrayList<INFO_DL>();
		INFO_DL infoItem = null;
		JSONObject jsonObj = null;
		for (int i = 0; i < jsonArray.length(); i++) {
			infoItem = new INFO_DL();
			jsonObj = jsonArray.optJSONObject(i);
			infoItem.md5 = jsonObj.optString("md5");
			infoItem.url = jsonObj.optString("url");
			infoItem.DLFlag = jsonObj.optBoolean("DLFlag");
			infoItem.savePath = jsonObj.optString("savePath");
			infoItem.dlIndex = jsonObj.optInt("dlIndex");
			infoItem.reTry = jsonObj.optInt("reTry");
			infoItem.copyPath = jsonObj.optString("copyPath");
			infoItem.fileType = jsonObj.optString("fileType");
			jsonList.add(infoItem);
		}
		return jsonList;
	
	}
	
	/**
	 * 根据固件版本获取序列号
	 * @param version
	 * @return
	 */
	public static String getServiceByVersion(String version){
		String service = "";
		if(TextUtils.isEmpty(version)){
			return service;
		}
		int index = version.indexOf("-");
		if(-1 == index){
			return service;
		}
		
		return version.substring(0, index);
		
	}

	/**
	 * 存云端时间
	 * 
	 * @param cloudTimestamp
	 */
	public static void setCloudTimestamp(String cloudTimestamp) {
		saveGlobalData(Define.KEY_SCREEN_CLOUDTIMESTAMP, cloudTimestamp);
	}

	/**
	 * 获取云端时间戳
	 * 
	 * @return 云端时间戳
	 */
	public static String getCloudTimestamp() {
		String cloudTimestamp = getGlobalData(Define.KEY_SCREEN_CLOUDTIMESTAMP);
		if (!TextUtils.isEmpty(cloudTimestamp)) {
			return cloudTimestamp;
		}
		return "";
	}

	/**
	 * 存屏保同步的时间戳，用于和云端时间戳比较
	 * 
	 * @param timestamp
	 */
	public static void setScreenTimestamp(String timestamp) {
		saveGlobalData(Define.KEY_SCREEN_TIMESTAMP, timestamp);
	}

	/**
	 * 获取屏保同步时间戳
	 * 
	 * @return 上次同步时间，第一次为""
	 */
	public static String getScreenTimestamp() {
		String timestamp = getGlobalData(Define.KEY_SCREEN_TIMESTAMP);
		if (!TextUtils.isEmpty(timestamp)) {
			return timestamp;
		}
		return "";
	}

	/**
	 * 存当前屏保正在使用的图片目录
	 * 
	 * @param screenUsingPath
	 *            正在使用的图片目录
	 */
	public static void setScreenPath(String screenUsingPath) {
		saveGlobalData(Define.KEY_SCREEN_USINGPATH, screenUsingPath);
	}

	/**
	 * 获取当前屏保正在使用的图片目录
	 * 
	 * @return 屏保正在使用的目录，第一次为"",第一次进入屏保后该值应设置为PathA
	 */
	public static String getScreenPath() {
		String screenPath = getGlobalData(Define.KEY_SCREEN_USINGPATH);
		if (!TextUtils.isEmpty(screenPath)) {
			return screenPath;
		}
		return "";
	}

	/**
	 * 存屏保当前使用Json
	 * 
	 * @param usingJson
	 */
	public static void setUsingJson(String usingJson) {
		saveGlobalData(Define.KEY_SCREEN_JSONUSING, usingJson);
	}

	/**
	 * 获取屏保当前使用Json
	 * 
	 * @return 当前使用的Json文件信息，第一次为""
	 */
	public static String getUsingJson() {
		String usingJson = getGlobalData(Define.KEY_SCREEN_JSONUSING);
		if (!TextUtils.isEmpty(usingJson)) {
			return usingJson;
		}
		return "";
	}

	/**
	 * 存下载图片使用Json
	 * 
	 * @param DLJson
	 */
	public static void setDLJson(String DLJson) {
		saveGlobalData(Define.KEY_SCREEN_JSONDL, DLJson);
	}

	/**
	 * 获取下载图片使用Json
	 * 
	 * @return 下载图片用到的Json文件
	 */
	public static String getDLJson() {
		String DLJson = getGlobalData(Define.KEY_SCREEN_JSONDL);
		if (!TextUtils.isEmpty(DLJson)) {
			return DLJson;
		}
		return "";
	}

	/**
	 * 存图片是否完全下载成功
	 * 
	 * @param fullDL
	 *            true: 100%下载 ，false:未完全下载
	 */
	public static void setFullDLFlag(boolean fullDL) {
		String fullDLFlag = "0";
		if (fullDL) {
			fullDLFlag = "1";
		}
		saveGlobalData(Define.KEY_SCREEN_FULLDL, fullDLFlag);

	}

	/**
	 * 获取图片是否完全下载成功
	 * 
	 * @return true:完全下载，false:未完全下载
	 */
	public static boolean getFullDLFlag() {
		String fullDLFlag = getGlobalData(Define.KEY_SCREEN_FULLDL);
		if (!TextUtils.isEmpty(fullDLFlag) && "1".equals(fullDLFlag)) {
			return true;
		}
		return false;
	}
	
	private static void saveGlobalData(String key, String value){
		Common.getGlobalData().setGlobalData(key, value);
	}
	
	private static String getGlobalData(String key){
		return Common.getGlobalData().getGlobalData(key);
	}

}

下载管理类

public class PicDownloadManager implements Runnable{
	private int dlIndex = 0;
	private INFO_DL dlInfo = null;
	private String dlPath = "";
	private Handler mHandler = null;
	private int messageType = 1; // 消息类型，用于区分是否全量下载（无copy）
	private ArrayList<INFO_DL> dlList = new ArrayList<INFO_DL>();
	
	/**
	 * 下载管理类，负责从云端下载图片，包括下载成功后Md5Check，以及下载失败后最多3次重试
	 * @param dlList 下载List
	 * @param handler 下载完成后发送消息到主线程
	 * @param messageType 发送消息类型（包括全量下载、部分下载）
	 */
	public PicDownloadManager(ArrayList<INFO_DL> dlList, Handler handler, int messageType){
		this.messageType = messageType;
		this.dlList = dlList;
		mHandler = handler;
		initDLPath();
	}
	/**
	 * 初始化下载路径（绝对路径/data/data../PathA或PathB）
	 */
	private void initDLPath(){
		dlPath = PicSyncHelper.getInstance().getDLPath();
	}
	
	public void dlStart(){
		dlInfo = dlList.get(dlIndex);
		PicDownloader pic = new  PicDownloader(dlPath ,dlInfo ,mDLListener);
		pic.download();
	}
	
	@Override
	public void run() {
		dlStart();
	}
	
	/**
	 * 下载监听，用于响应下载成功、下载失败以后的处理
	 */
	private IDLListener mDLListener = new IDLListener() {
		
		@Override
		public void onFinish(INFO_DL info) {
			// md5 check
			// error retry,success dl next
			if(Utils.MD5Check(info.savePath, info.md5)){ // check success
				LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicDownloadManager -- onFinish Md5check success");
				info.DLFlag = true;
				PicSyncHelper.getInstance().updateDLJson(info.dlIndex, info); // update dlJson
				if(dlIndex < dlList.size() - 1){
					dlIndex++;
					dlInfo = dlList.get(dlIndex);
					PicDownloader pic = new  PicDownloader(dlPath, dlInfo, mDLListener);
					pic.download();
				}
				else{
					mHandler.sendEmptyMessage(messageType);
				}
			}
			else{ // download error
				dealError(info);
				LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicDownloadManager -- onFinish Md5check error");
			}
		}
		
		@Override
		public void onError(INFO_DL info) {
			// retry limit , download next
			dealError(info);
			LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicDownloadManager -- onError");
		}
	};
	
	/**
	 * 处理下载失败的情况（包括下载成功但MD5 check失败的情况）
	 * @param info
	 */
	private void dealError(INFO_DL info){
		
		if(info.reTry < PicCons.MAX_RETRY){
			info.reTry ++;
			PicDownloader pic = new  PicDownloader(dlPath, info, mDLListener);
			pic.download();
		}
		else{
			if(dlIndex < dlList.size() - 1){
				dlIndex++;
				dlInfo = dlList.get(dlIndex);
				PicDownloader pic = new  PicDownloader(dlPath, dlInfo, mDLListener);
				pic.download();
			}
			else{
				mHandler.sendEmptyMessage(messageType);
			}
		}
	}
	
	public interface IDLListener {
	void onError(INFO_DL info);
	void onFinish(INFO_DL info);
	}

}

}

下载类

public class PicDownloader{
	private String savePath;
	private INFO_DL DLInfo;
	private IDLListener listener;
	private String picName;

	
	/**
	 * 执行图片下载类
	 * @param savePath 图片保存的路径
	 * @param DLInfo  下载封装信息体
	 * @param listener 下载状态回调
	 */
	public PicDownloader(String savePath,INFO_DL DLInfo,IDLListener listener){
		this.savePath = savePath;
		this.DLInfo = DLInfo;
		this.listener = listener;
		picName = DLInfo.md5+DLInfo.fileType;
	}
	/**
	 * 开始下载
	 */
	public void download() {
		HttpURLConnection conn = null;
        try {
			conn = (HttpURLConnection) new URL(DLInfo.url).openConnection();
			conn.setConnectTimeout(PicCons.DEFAULT_TIMEOUT);
			conn.setReadTimeout(PicCons.DEFAULT_TIMEOUT);
			addRequestHeaders(conn);
			final int code = conn.getResponseCode();
			LogHelper.releaseLog(PicCons.SCREEN_TAG,"PicDownloader -- run getResponseCode : " + code);
			if (PicCons.HTTP_OK == code) {
				dlInit(conn, code);
			}
			else{
				LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicDownloader -- run listener.onError");
				if(null != listener){
					listener.onError(DLInfo);
				}
				return;
			}
            } catch (Exception e) {
            	e.printStackTrace();
            	if(null != listener){
    				listener.onError(DLInfo);
    			}
            	LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicDownloader -- run has an Exception");

            } finally {
                if (null != conn) 
                	conn.disconnect();
            }
			
		}
	
	
	
	private void dlInit(HttpURLConnection conn, int code){
        if (!createFile(savePath, picName)){
        	LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicDownloader -- dlInit Can not create file:"+savePath+"picName");
        	if(null != listener){
				listener.onError(DLInfo);
			}
        	return;
        }
        dlData(conn);
    }
	
	private void dlData(HttpURLConnection conn){
		InputStream is = null;
		FileOutputStream fos = null;
		try {
			is = conn.getInputStream();
			fos = new FileOutputStream(new File(savePath, picName));
			byte [] b = new byte[4096];
			int len;
			while((len = is.read(b)) != -1){
				fos.write(b, 0, len);
			}
			LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicDownloader -- dlData download finish : "+savePath+"-"+DLInfo.md5);
		    if(null != listener){
		    	listener.onFinish(DLInfo);
		    }
			
		} catch (IOException e) {
			e.printStackTrace();
			if(null != listener){
				listener.onError(DLInfo);
			}
			LogHelper.releaseLog(PicCons.SCREEN_TAG, "PicDownloader -- dlData has an Exception");
			return;
		} finally {
			try {
				if(null != is){
					is.close();
				}
				if(null != fos){
					fos.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}



	
	private synchronized boolean createFile(String path, String fileName) {
        boolean hasFile = false;
        try {
            File dir = new File(path);
            boolean hasDir = dir.exists() || dir.mkdirs();
            if (hasDir) {
                File file = new File(dir, fileName);
                hasFile = file.exists() || file.createNewFile();
                DLInfo.savePath = file.getPath();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return hasFile;
    }
		
	private void addRequestHeaders(HttpURLConnection conn) {
            conn.addRequestProperty("Accept", "image/gif, image/jpeg, image/pjpeg, image/pjpeg," +
                    "application/x-shockwave-flash, application/xaml+xml," +
                    "application/vnd.ms-xpsdocument, application/x-ms-xbap," +
                    "application/x-ms-application, application/vnd.ms-excel," +
                    "application/vnd.ms-powerpoint, application/msword, */*");
            conn.addRequestProperty("Charset", "UTF-8");
            conn.addRequestProperty("Connection", "Keep-Alive");
            conn.addRequestProperty("Accept-Encoding", "identity");
            
    }

}

上面就是图片同步的整个过程，欢迎大家讨论。

谢谢。