Android资源存取工具类

转载自： http://blog.csdn.net/linxcool/article/details/9056841

[java] view plain copy print ?

1. /** 
2.  * 资源管理类 
3.  * @author: linxcool.hu 
4.  */  
5. public class ResourceManager {  
6.     private static final String TAG="ResourceManager";  
7.     private static ResourceManager resourceManager=new ResourceManager();  
8.     private List<Bitmap> bitmapCaches;  
9.       
10.     private ResourceManager(){  
11.         bitmapCaches=new ArrayList<Bitmap>();  
12.     }  
13.     public static ResourceManager getInstance(){  
14.         return resourceManager;  
15.     }  
16.     /** 
17.      * 检查SD卡是否存在 
18.      * @return 存在返回true，否则返回false 
19.      */  
20.     public boolean isSdcardReady(){  
21.         boolean sdCardExist = Environment.getExternalStorageState().equals(  
22.                     android.os.Environment.MEDIA_MOUNTED);  
23.         return sdCardExist;  
24.     }  
25.     /** 
26.      * 获得SD路径 
27.      * @return 
28.      */  
29.     public String getSdcardPath() {  
30.         return Environment.getExternalStorageDirectory().toString()+ File.separator;  
31.     }  
32.       
33.     /** 
34.      * 获取手机该应用的私有路径 
35.      * @param context 
36.      * @return 
37.      */  
38.     public String getRomCachePath(Context context){  
39.         return context.getCacheDir() + File.separator;  
40.     }  
41.       
42.     /** 
43.      * 检查SD卡中是否存在该文件 
44.      * @param filePath 不包含SD卡目录的文件路径 
45.      * @return 
46.      */  
47.     public boolean isSdcardFileExist(String filePath){  
48.         File file=new File(getSdcardPath()+filePath);  
49.         return file.exists();  
50.     }  
51.       
52.     /** 
53.      *  检查手机内存中是否存在该文件 
54.      * @param context 
55.      * @param fileName 不包含应用内存目录的文件路径 
56.      * @return 
57.      */  
58.     public boolean isRomCacheFileExist(Context context,String filePath){  
59.         String cachePath = getRomCachePath(context);  
60.         File file=new File(cachePath+filePath);  
61.         return file.exists();  
62.     }  
63.       
64.     /** 
65.      * 构建SD目录 
66.      * @param path 不包含SD卡目录的文件全路径 
67.      * @return 
68.      */  
69.     public String mkSdcardFileDirs(String path) {  
70.         String rsPath =getSdcardPath() + path;  
71.         File file = new File(rsPath);  
72.         if (!file.exists())file.mkdirs();  
73.         return rsPath;  
74.     }  
75.       
76.     /** 
77.      * 构建手机存储文件路径 
78.      * @param context 
79.      * @param path 不包含应用内存目录的文件全路径 
80.      * @return 
81.      */  
82.     public String mkRomCacheDirs(Context context,String path) {  
83.         String cachePath = getRomCachePath(context);  
84.         String rsPath=cachePath+path;  
85.         File file = new File(rsPath);  
86.         if (!file.exists())file.mkdirs();  
87.         return rsPath;  
88.     }  
89.       
90.     /** 
91.      * 保存图片文件 
92.      * @param bmp 
93.      * @param fullFilePath 保存的完整路径 
94.      * @return 返回true如果图片保存失败或图片已存在，否则返回false 
95.      */  
96.     public boolean saveBitmap(Bitmap bmp,String fullFilePath) {  
97.         if(fullFilePath==null||fullFilePath.length()<1){  
98.             Log.e(TAG, "saveBitmap error as filePath invalid");  
99.             return false;  
100.         }  
101.         FileOutputStream fos = null;  
102.         File file = new File(fullFilePath);  
103.         if(file.exists())return false;  
104.         try {  
105.             fos = new FileOutputStream(file);  
106.             if (null != fos) {  
107.                 bmp.compress(Bitmap.CompressFormat.PNG, 90, fos);  
108.                 fos.flush();  
109.                 fos.close();  
110.                 return true;  
111.             }  
112.         } catch (IOException e) {  
113.             Log.e(TAG, "saveBitmap fail as "+e.getMessage());  
114.         }  
115.         return false;  
116.     }  
117.       
118.     /** 
119.      * 保存图片到SD卡 
120.      * @param bmp 图片文件 
121.      * @param filePath  
122.      */  
123.     public boolean saveBitmap2Sdcard(Bitmap bmp,String filePath) {  
124.         if(!isSdcardReady()){  
125.             Log.e(TAG, "saveBitmap2Sdcard error as sdCard not exist");  
126.             return false;  
127.         }  
128.         return saveBitmap(bmp, getSdcardPath()+filePath);  
129.     }  
130.       
131.     /** 
132.      * 保存图片到手机内存 
133.      * @param context 
134.      * @param bmp 图片文件 
135.      * @param filePath  
136.      * @return 
137.      */  
138.     public boolean saveBitmap2RomCache(Context context,Bitmap bmp,String filePath){  
139.         return saveBitmap(bmp, getRomCachePath(context)+filePath);  
140.     }  
141.       
142.     /** 
143.      * 获取图片资源 
144.      * @param fullFilePath 
145.      * @return 
146.      */  
147.     public Bitmap getBitmap(String fullFilePath){  
148.         try {  
149.             File file=new File(fullFilePath);  
150.             if(file.exists()){  
151.                 Bitmap bitmap = BitmapFactory.decodeFile(fullFilePath);  
152.                 bitmapCaches.add(bitmap);  
153.                 return bitmap;  
154.             }  
155.         } catch (Exception e) {  
156.             Log.e(TAG, "getBitmap fail as "+e.getMessage());  
157.         }  
158.         return null;  
159.     }  
160.       
161.     /** 
162.      * 从SD卡获取图片资源 
163.      * @param fullFilePath 
164.      * @return 
165.      */  
166.     public Bitmap getBitmapFromSdcard(String filePath){  
167.         return getBitmap(getSdcardPath()+filePath);  
168.     }  
169.       
170.     /** 
171.      * 从手机内存获取图片资源 
172.      * @param fullFilePath 
173.      * @return 
174.      */  
175.     public Bitmap getBitmapFromRomCache(Context context,String filePath){  
176.         return getBitmap(getRomCachePath(context)+filePath);  
177.     }  
178.       
179.     /** 
180.      * 获得包路径下的图片文件 
181.      * @param pkgPath 
182.      * @param fileName 
183.      * @return 
184.      */  
185.     public Bitmap getBitmapFromPackage(Class<?> clazz,String pkgPath,String fileName) {  
186.         InputStream is = clazz.getResourceAsStream(pkgPath+fileName);  
187.         try {  
188.             if (null == is || is.available() <= 0)return null;  
189.         } catch (IOException ioe) {  
190.             Log.e(TAG, ioe.getMessage());  
191.             try {  
192.                 if (is != null)is.close();  
193.             }catch (Exception e) {}  
194.             return null;  
195.         }  
196.         try {  
197.             Bitmap bitmap=BitmapFactory.decodeStream(is);  
198.             bitmapCaches.add(bitmap);  
199.             return bitmap;  
200.         }catch (Exception e) {  
201.             Log.e(TAG, "getBitmapFromPackage fail as "+e.getMessage());  
202.         }finally {  
203.             try {  
204.                 if (is != null)is.close();  
205.             }catch (Exception e) {}  
206.         }  
207.         return null;  
208.     }  
209.       
210.     /** 
211.      *  获得包路径下的.9.png格式图片 
212.      * @param clazz 
213.      * @param pkgPath 
214.      * @param picName 
215.      * @return 
216.      */  
217.     public Drawable get9pngDrawableFromPackage(  
218.             Class<?> clazz,String pkgPath, String picName) {  
219.         InputStream inputStream = clazz.getResourceAsStream(pkgPath + picName);  
220.         try {  
221.             if (null == inputStream || inputStream.available() <= 0)   
222.                 return null;  
223.         }   
224.         catch (IOException e1) {  
225.             try {  
226.                 if (inputStream != null)   
227.                     inputStream.close();  
228.             }   
229.             catch (Exception e) {}  
230.             return null;  
231.         }  
232.         Bitmap bitmap = null;  
233.         NinePatchDrawable patchy = null;  
234.         try {  
235.             bitmap = BitmapFactory.decodeStream(inputStream);  
236.             bitmapCaches.add(bitmap);  
237.             byte[] chunk = bitmap.getNinePatchChunk();  
238.             boolean result = NinePatch.isNinePatchChunk(chunk);  
239.             if (result) patchy = new NinePatchDrawable(bitmap, chunk, new Rect(), null);  
240.         }   
241.         catch (Exception e) {}   
242.         finally {  
243.             try {  
244.                 if (inputStream != null)   
245.                     inputStream.close();  
246.             }   
247.             catch (Exception e) {}  
248.         }  
249.         return patchy;  
250.     }  
251.   
252.     /** 
253.      * 释放引用的图片 
254.      */  
255.     public void recycleBitmaps(){  
256.         for (int i = 0; i < bitmapCaches.size(); i++) {  
257.             bitmapCaches.get(i).recycle();  
258.         }  
259.         bitmapCaches.clear();  
260.     }  
261.       
262.     /** 
263.      * 从文件中读取字符串 
264.      * @param file 
265.      * @return 
266.      */  
267.     public String readStringFile(File file){  
268.         try {  
269.             InputStream is = new FileInputStream(file);  
270.             return readString(is);  
271.         } catch (FileNotFoundException e) {  
272.             e.printStackTrace();  
273.         }  
274.         return null;  
275.     }  
276.   
277.     /** 
278.      * 从文件中读取字符串 
279.      * @param file 
280.      * @return 
281.      */  
282.     public String readStringFromPackage(Class<?> clazz,String pkgPath,String fileName){  
283.         try {  
284.             InputStream is=clazz.getResourceAsStream(pkgPath+fileName);  
285.             return readString(is);  
286.         } catch (Exception e) {  
287.             e.printStackTrace();  
288.         }  
289.         return null;  
290.     }  
291.       
292.     private String readString(InputStream is){  
293.         ByteArrayOutputStream bos = null;  
294.         try{  
295.             bos = new ByteArrayOutputStream();  
296.             byte[] buffer = new byte[1024];  
297.             int length = -1;  
298.             while( (length = is.read(buffer)) != -1){  
299.                 bos.write(buffer,0,length);  
300.             }  
301.             return bos.toString();   
302.         } catch(Exception e){  
303.             Log.e(TAG, "readStringFromPackage fail as "+e.getMessage());  
304.         }finally{  
305.             try {bos.close();  
306.             } catch (IOException e) {}  
307.             try {is.close();  
308.             } catch (IOException e) {}  
309.         }  
310.         return null;  
311.     }  
312.       
313.     /** 
314.      * 从SD卡读取字符文件 
315.      * @param filePath 
316.      * @return 
317.      */  
318.     public String readStringFileFromSdcard(String filePath) {  
319.         if(!isSdcardReady()){  
320.             Log.e(TAG, "saveBitmap2Sdcard error as sdCard not exist");  
321.             return null;  
322.         }  
323.         File file=new File(getSdcardPath()+filePath);  
324.         return readStringFile(file);  
325.     }  
326.       
327.     /** 
328.      * 从手机内存读取字符文件 
329.      * @param filePath 
330.      * @return 
331.      */  
332.     public String readStringFileFromRomCache(Context context,String filePath) {  
333.         File file=new File(getRomCachePath(context)+filePath);  
334.         return readStringFile(file);  
335.     }  
336.       
337.     /** 
338.      * 存储字符文件 
339.      * @param fullFilePath 完整路径 
340.      * @param content 字符内容 
341.      * @return 
342.      */  
343.     public boolean saveStringFile(String fullFilePath,String content){  
344.         File file = new File(fullFilePath);  
345.         FileOutputStream fos = null;  
346.         try {  
347.             fos = new FileOutputStream(file);  
348.             fos.write(content.getBytes());  
349.             return true;  
350.         } catch (IOException e) {  
351.             Log.e(TAG, "saveData fail as "+e.getMessage());  
352.         }finally{  
353.             try {  
354.                 if(fos!=null) fos.close();  
355.             } catch (IOException e) {}  
356.         }  
357.         return false;  
358.     }  
359.       
360.     /** 
361.      *  存储字符文件到手机内存 
362.      * @param context 
363.      * @param fileName 
364.      * @param content 
365.      * @return 
366.      */  
367.     public boolean saveStringFile2RomCache(Context context,String filePath,String content){  
368.         String cachePath = getRomCachePath(context);  
369.         return saveStringFile(cachePath+filePath, content);  
370.     }  
371.       
372.     /** 
373.      * 存储字符文件到SD卡 
374.      * @param filePath 
375.      * @param content 
376.      * @return 
377.      */  
378.     public boolean saveStringFile2Sdcard(String filePath,String content) {  
379.         if(!isSdcardReady()){  
380.             Log.e(TAG, "saveStringFile2Sdcard error as sdCard not exist");  
381.             return false;  
382.         }  
383.         return saveStringFile(getSdcardPath()+filePath,content);  
384.     }  
385. }  

/**
 * 资源管理类
 * @author: linxcool.hu
 */
public class ResourceManager {
	private static final String TAG="ResourceManager";
	private static ResourceManager resourceManager=new ResourceManager();
	private List<Bitmap> bitmapCaches;
	
	private ResourceManager(){
		bitmapCaches=new ArrayList<Bitmap>();
	}
	public static ResourceManager getInstance(){
		return resourceManager;
	}
	/**
	 * 检查SD卡是否存在
	 * @return 存在返回true，否则返回false
	 */
	public boolean isSdcardReady(){
		boolean sdCardExist = Environment.getExternalStorageState().equals(
					android.os.Environment.MEDIA_MOUNTED);
		return sdCardExist;
	}
	/**
	 * 获得SD路径
	 * @return
	 */
	public String getSdcardPath() {
		return Environment.getExternalStorageDirectory().toString()+ File.separator;
	}
	
	/**
	 * 获取手机该应用的私有路径
	 * @param context
	 * @return
	 */
	public String getRomCachePath(Context context){
		return context.getCacheDir() + File.separator;
	}
	
	/**
	 * 检查SD卡中是否存在该文件
	 * @param filePath 不包含SD卡目录的文件路径
	 * @return
	 */
	public boolean isSdcardFileExist(String filePath){
		File file=new File(getSdcardPath()+filePath);
		return file.exists();
	}
	
	/**
	 *  检查手机内存中是否存在该文件
	 * @param context
	 * @param fileName 不包含应用内存目录的文件路径
	 * @return
	 */
	public boolean isRomCacheFileExist(Context context,String filePath){
		String cachePath = getRomCachePath(context);
		File file=new File(cachePath+filePath);
		return file.exists();
	}
	
	/**
	 * 构建SD目录
	 * @param path 不包含SD卡目录的文件全路径
	 * @return
	 */
	public String mkSdcardFileDirs(String path) {
		String rsPath =getSdcardPath() + path;
		File file = new File(rsPath);
		if (!file.exists())file.mkdirs();
		return rsPath;
	}
	
	/**
	 * 构建手机存储文件路径
	 * @param context
	 * @param path 不包含应用内存目录的文件全路径
	 * @return
	 */
	public String mkRomCacheDirs(Context context,String path) {
		String cachePath = getRomCachePath(context);
		String rsPath=cachePath+path;
		File file = new File(rsPath);
		if (!file.exists())file.mkdirs();
		return rsPath;
	}
	
	/**
	 * 保存图片文件
	 * @param bmp
	 * @param fullFilePath 保存的完整路径
	 * @return 返回true如果图片保存失败或图片已存在，否则返回false
	 */
	public boolean saveBitmap(Bitmap bmp,String fullFilePath) {
		if(fullFilePath==null||fullFilePath.length()<1){
			Log.e(TAG, "saveBitmap error as filePath invalid");
			return false;
		}
		FileOutputStream fos = null;
		File file = new File(fullFilePath);
		if(file.exists())return false;
		try {
			fos = new FileOutputStream(file);
			if (null != fos) {
				bmp.compress(Bitmap.CompressFormat.PNG, 90, fos);
				fos.flush();
				fos.close();
				return true;
			}
		} catch (IOException e) {
			Log.e(TAG, "saveBitmap fail as "+e.getMessage());
		}
		return false;
	}
	
	/**
	 * 保存图片到SD卡
	 * @param bmp 图片文件
	 * @param filePath 
	 */
	public boolean saveBitmap2Sdcard(Bitmap bmp,String filePath) {
		if(!isSdcardReady()){
			Log.e(TAG, "saveBitmap2Sdcard error as sdCard not exist");
			return false;
		}
		return saveBitmap(bmp, getSdcardPath()+filePath);
	}
	
	/**
	 * 保存图片到手机内存
	 * @param context
	 * @param bmp 图片文件
	 * @param filePath 
	 * @return
	 */
	public boolean saveBitmap2RomCache(Context context,Bitmap bmp,String filePath){
		return saveBitmap(bmp, getRomCachePath(context)+filePath);
	}
	
	/**
	 * 获取图片资源
	 * @param fullFilePath
	 * @return
	 */
	public Bitmap getBitmap(String fullFilePath){
		try {
			File file=new File(fullFilePath);
			if(file.exists()){
				Bitmap bitmap = BitmapFactory.decodeFile(fullFilePath);
				bitmapCaches.add(bitmap);
				return bitmap;
			}
		} catch (Exception e) {
			Log.e(TAG, "getBitmap fail as "+e.getMessage());
		}
		return null;
	}
	
	/**
	 * 从SD卡获取图片资源
	 * @param fullFilePath
	 * @return
	 */
	public Bitmap getBitmapFromSdcard(String filePath){
		return getBitmap(getSdcardPath()+filePath);
	}
	
	/**
	 * 从手机内存获取图片资源
	 * @param fullFilePath
	 * @return
	 */
	public Bitmap getBitmapFromRomCache(Context context,String filePath){
		return getBitmap(getRomCachePath(context)+filePath);
	}
	
	/**
	 * 获得包路径下的图片文件
	 * @param pkgPath
	 * @param fileName
	 * @return
	 */
	public Bitmap getBitmapFromPackage(Class<?> clazz,String pkgPath,String fileName) {
		InputStream is = clazz.getResourceAsStream(pkgPath+fileName);
		try {
			if (null == is || is.available() <= 0)return null;
		} catch (IOException ioe) {
			Log.e(TAG, ioe.getMessage());
			try {
				if (is != null)is.close();
			}catch (Exception e) {}
			return null;
		}
		try {
			Bitmap bitmap=BitmapFactory.decodeStream(is);
			bitmapCaches.add(bitmap);
			return bitmap;
		}catch (Exception e) {
			Log.e(TAG, "getBitmapFromPackage fail as "+e.getMessage());
		}finally {
			try {
				if (is != null)is.close();
			}catch (Exception e) {}
		}
		return null;
	}
	
	/**
	 *  获得包路径下的.9.png格式图片
	 * @param clazz
	 * @param pkgPath
	 * @param picName
	 * @return
	 */
	public Drawable get9pngDrawableFromPackage(
			Class<?> clazz,String pkgPath, String picName) {
		InputStream inputStream = clazz.getResourceAsStream(pkgPath + picName);
		try {
			if (null == inputStream || inputStream.available() <= 0) 
				return null;
		} 
		catch (IOException e1) {
			try {
				if (inputStream != null) 
					inputStream.close();
			} 
			catch (Exception e) {}
			return null;
		}
		Bitmap bitmap = null;
		NinePatchDrawable patchy = null;
		try {
			bitmap = BitmapFactory.decodeStream(inputStream);
			bitmapCaches.add(bitmap);
			byte[] chunk = bitmap.getNinePatchChunk();
			boolean result = NinePatch.isNinePatchChunk(chunk);
			if (result) patchy = new NinePatchDrawable(bitmap, chunk, new Rect(), null);
		} 
		catch (Exception e) {} 
		finally {
			try {
				if (inputStream != null) 
					inputStream.close();
			} 
			catch (Exception e) {}
		}
		return patchy;
	}

	/**
	 * 释放引用的图片
	 */
	public void recycleBitmaps(){
		for (int i = 0; i < bitmapCaches.size(); i++) {
			bitmapCaches.get(i).recycle();
		}
		bitmapCaches.clear();
	}
	
	/**
	 * 从文件中读取字符串
	 * @param file
	 * @return
	 */
	public String readStringFile(File file){
		try {
			InputStream is = new FileInputStream(file);
			return readString(is);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 从文件中读取字符串
	 * @param file
	 * @return
	 */
	public String readStringFromPackage(Class<?> clazz,String pkgPath,String fileName){
		try {
			InputStream is=clazz.getResourceAsStream(pkgPath+fileName);
			return readString(is);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}
	
	private String readString(InputStream is){
		ByteArrayOutputStream bos = null;
		try{
			bos = new ByteArrayOutputStream();
			byte[] buffer = new byte[1024];
			int length = -1;
			while( (length = is.read(buffer)) != -1){
				bos.write(buffer,0,length);
			}
			return bos.toString(); 
		} catch(Exception e){
			Log.e(TAG, "readStringFromPackage fail as "+e.getMessage());
		}finally{
			try {bos.close();
			} catch (IOException e) {}
			try {is.close();
			} catch (IOException e) {}
		}
		return null;
	}
	
	/**
	 * 从SD卡读取字符文件
	 * @param filePath
	 * @return
	 */
	public String readStringFileFromSdcard(String filePath) {
		if(!isSdcardReady()){
			Log.e(TAG, "saveBitmap2Sdcard error as sdCard not exist");
			return null;
		}
		File file=new File(getSdcardPath()+filePath);
		return readStringFile(file);
	}
	
	/**
	 * 从手机内存读取字符文件
	 * @param filePath
	 * @return
	 */
	public String readStringFileFromRomCache(Context context,String filePath) {
		File file=new File(getRomCachePath(context)+filePath);
		return readStringFile(file);
	}
	
	/**
	 * 存储字符文件
	 * @param fullFilePath 完整路径
	 * @param content 字符内容
	 * @return
	 */
	public boolean saveStringFile(String fullFilePath,String content){
		File file = new File(fullFilePath);
		FileOutputStream fos = null;
		try {
			fos = new FileOutputStream(file);
			fos.write(content.getBytes());
			return true;
		} catch (IOException e) {
			Log.e(TAG, "saveData fail as "+e.getMessage());
		}finally{
			try {
				if(fos!=null) fos.close();
			} catch (IOException e) {}
		}
		return false;
	}
	
	/**
	 *  存储字符文件到手机内存
	 * @param context
	 * @param fileName
	 * @param content
	 * @return
	 */
	public boolean saveStringFile2RomCache(Context context,String filePath,String content){
		String cachePath = getRomCachePath(context);
		return saveStringFile(cachePath+filePath, content);
	}
	
	/**
	 * 存储字符文件到SD卡
	 * @param filePath
	 * @param content
	 * @return
	 */
	public boolean saveStringFile2Sdcard(String filePath,String content) {
		if(!isSdcardReady()){
			Log.e(TAG, "saveStringFile2Sdcard error as sdCard not exist");
			return false;
		}
		return saveStringFile(getSdcardPath()+filePath,content);
	}
}

[java] view plain copy print ?

1. public class ResUtil {  
2.     public static final String SD_IMG_PATH="istore/images/";  
3.     public static final String ROM_IMG_PATH="images/";  
4.     public static final String SD_DATA_PATH="istore/data/";  
5.     public static final String ROM_DATA_PATH="data/";  
6.       
7.     public static final String PKG_PATH = "/com/linxcool/istore/";  
8.     public static final String PKG_RES_PATH = PKG_PATH+"res/";  
9.       
10.     /** 
11.      * 获得包图片资源 
12.      * @param picName 
13.      * @return 
14.      */  
15.     public static Bitmap getBitmapFromPackage(String picName){  
16.         return ResourceManager.getInstance().getBitmapFromPackage(  
17.                 ResUtil.class,PKG_RES_PATH, picName);  
18.     }  
19.       
20.     /** 
21.      * 获得包.9.png图片资源 
22.      * @param picName 
23.      * @return 
24.      */  
25.     public static Drawable get9pngDrawableFromPackage(String picName){  
26.         return ResourceManager.getInstance().get9pngDrawableFromPackage(  
27.                 ResUtil.class, PKG_RES_PATH, picName);  
28.     }  
29.       
30.     /** 
31.      * 获得SD_APK_PATH路径下的APK文件 
32.      * @return 
33.      */  
34.     public static List<File> getApkFiles(){  
35.         File filesPath=new File(  
36.                 ResourceManager.getInstance().getSdcardPath()+SD_APK_PATH);  
37.         if(!filesPath.exists())return null;  
38.         File[] files=filesPath.listFiles();  
39.         if(files==null || files.length==0)return null;  
40.           
41.         List<File> list=new ArrayList<File>();  
42.         for (File file : files) {  
43.             if(file.isDirectory())continue;  
44.             String fileName=file.getName().toLowerCase();  
45.             if(fileName.contains(".apk"))  
46.                 list.add(file);  
47.         }  
48.         return list;  
49.     }  
50.       
51.     public static String getFolderFromPath(String path) {  
52.         String[] slipArray = path.split(File.separator);  
53.         if( slipArray.length <= 0 )  
54.             return null;  
55.         int pathLen = path.length();  
56.         int fileNameLen = slipArray[slipArray.length-1].length();  
57.         return path.substring(0, pathLen-fileNameLen);  
58.     }  
59.       
60.     public static String readStringFromPackage(String fileName){  
61.         return ResourceManager.getInstance().readStringFromPackage(  
62.                 ResUtil.class,PKG_RES_PATH, fileName);  
63.     }  
64.       
65.     /** 
66.      * 保存String数据 
67.      * @param context 
68.      * @param fileName 
69.      * @param content 
70.      */  
71.     public static void saveStringData(Context context,String fileName,String content){  
72.         if(ResourceManager.getInstance().isSdcardReady()){  
73.             String filePath=SD_DATA_PATH+fileName;  
74.             String folder=getFolderFromPath(filePath);  
75.             ResourceManager.getInstance().mkSdcardFileDirs(folder);  
76.             ResourceManager.getInstance().  
77.             saveStringFile2Sdcard(filePath, content);  
78.         }else{  
79.             String filePath=ROM_DATA_PATH+fileName;  
80.             String folder=getFolderFromPath(filePath);  
81.             ResourceManager.getInstance().mkRomCacheDirs(context, folder);  
82.             ResourceManager.getInstance().  
83.             saveStringFile2RomCache(context, filePath, content);  
84.         }  
85.     }  
86.       
87.     /** 
88.      * 读取String数据 
89.      * @param context 
90.      * @param fileName 
91.      * @return 
92.      */  
93.     public static String readStringData(Context context,String fileName){  
94.         if(ResourceManager.getInstance().isSdcardFileExist(SD_DATA_PATH+fileName)){  
95.             return ResourceManager.getInstance().  
96.             readStringFileFromSdcard(SD_DATA_PATH+fileName);  
97.         }else if(ResourceManager.getInstance().isRomCacheFileExist(context, ROM_DATA_PATH+fileName)){  
98.             return ResourceManager.getInstance().  
99.             readStringFileFromRomCache(context,ROM_DATA_PATH+fileName);  
100.         }  
101.         return null;  
102.     }  
103.       
104.     /** 
105.      * 保存图片文件 
106.      * @param context 
107.      * @param bmp 
108.      * @param fileName 
109.      */  
110.     public static void saveBitmap(Context context,Bitmap bmp, String fileName){  
111.         if(ResourceManager.getInstance().isSdcardReady()){  
112.             String filePath=SD_IMG_PATH+fileName;  
113.             String folder=getFolderFromPath(filePath);  
114.             ResourceManager.getInstance().mkSdcardFileDirs(folder);  
115.             ResourceManager.getInstance().saveBitmap2Sdcard(bmp,filePath);  
116.         }else{  
117.             String filePath=ROM_IMG_PATH+fileName;  
118.             String folder=getFolderFromPath(filePath);  
119.             ResourceManager.getInstance().mkRomCacheDirs(context, folder);  
120.             ResourceManager.getInstance().  
121.             saveBitmap2RomCache(context, bmp, filePath);  
122.         }  
123.     }  
124.       
125.     /** 
126.      * 获得图片文件 
127.      * @param context 
128.      * @param fileName 
129.      * @return 
130.      */  
131.     public static Bitmap getBitmap(Context context,String fileName){  
132.         if(ResourceManager.getInstance().isSdcardFileExist(SD_IMG_PATH+fileName)){  
133.             return ResourceManager.getInstance().  
134.             getBitmapFromSdcard(SD_IMG_PATH+fileName);  
135.         }else if(ResourceManager.getInstance().isRomCacheFileExist(context, ROM_IMG_PATH+fileName)){  
136.             return ResourceManager.getInstance().  
137.             getBitmapFromRomCache(context,ROM_IMG_PATH+fileName);  
138.         }  
139.         return null;  
140.     }  
141.       
142. }  

public class ResUtil {
	public static final String SD_IMG_PATH="istore/images/";
	public static final String ROM_IMG_PATH="images/";
	public static final String SD_DATA_PATH="istore/data/";
	public static final String ROM_DATA_PATH="data/";
	
	public static final String PKG_PATH = "/com/linxcool/istore/";
	public static final String PKG_RES_PATH = PKG_PATH+"res/";
	
	/**
	 * 获得包图片资源
	 * @param picName
	 * @return
	 */
	public static Bitmap getBitmapFromPackage(String picName){
		return ResourceManager.getInstance().getBitmapFromPackage(
				ResUtil.class,PKG_RES_PATH, picName);
	}
	
	/**
	 * 获得包.9.png图片资源
	 * @param picName
	 * @return
	 */
	public static Drawable get9pngDrawableFromPackage(String picName){
		return ResourceManager.getInstance().get9pngDrawableFromPackage(
				ResUtil.class, PKG_RES_PATH, picName);
	}
	
	/**
	 * 获得SD_APK_PATH路径下的APK文件
	 * @return
	 */
	public static List<File> getApkFiles(){
		File filesPath=new File(
				ResourceManager.getInstance().getSdcardPath()+SD_APK_PATH);
		if(!filesPath.exists())return null;
		File[] files=filesPath.listFiles();
		if(files==null || files.length==0)return null;
		
		List<File> list=new ArrayList<File>();
		for (File file : files) {
			if(file.isDirectory())continue;
			String fileName=file.getName().toLowerCase();
			if(fileName.contains(".apk"))
				list.add(file);
		}
		return list;
	}
	
	public static String getFolderFromPath(String path) {
		String[] slipArray = path.split(File.separator);
		if( slipArray.length <= 0 )
			return null;
		int pathLen = path.length();
		int fileNameLen = slipArray[slipArray.length-1].length();
		return path.substring(0, pathLen-fileNameLen);
	}
	
	public static String readStringFromPackage(String fileName){
		return ResourceManager.getInstance().readStringFromPackage(
				ResUtil.class,PKG_RES_PATH, fileName);
	}
	
	/**
	 * 保存String数据
	 * @param context
	 * @param fileName
	 * @param content
	 */
	public static void saveStringData(Context context,String fileName,String content){
		if(ResourceManager.getInstance().isSdcardReady()){
			String filePath=SD_DATA_PATH+fileName;
			String folder=getFolderFromPath(filePath);
			ResourceManager.getInstance().mkSdcardFileDirs(folder);
			ResourceManager.getInstance().
			saveStringFile2Sdcard(filePath, content);
		}else{
			String filePath=ROM_DATA_PATH+fileName;
			String folder=getFolderFromPath(filePath);
			ResourceManager.getInstance().mkRomCacheDirs(context, folder);
			ResourceManager.getInstance().
			saveStringFile2RomCache(context, filePath, content);
		}
	}
	
	/**
	 * 读取String数据
	 * @param context
	 * @param fileName
	 * @return
	 */
	public static String readStringData(Context context,String fileName){
		if(ResourceManager.getInstance().isSdcardFileExist(SD_DATA_PATH+fileName)){
			return ResourceManager.getInstance().
			readStringFileFromSdcard(SD_DATA_PATH+fileName);
		}else if(ResourceManager.getInstance().isRomCacheFileExist(context, ROM_DATA_PATH+fileName)){
			return ResourceManager.getInstance().
			readStringFileFromRomCache(context,ROM_DATA_PATH+fileName);
		}
		return null;
	}
	
	/**
	 * 保存图片文件
	 * @param context
	 * @param bmp
	 * @param fileName
	 */
	public static void saveBitmap(Context context,Bitmap bmp, String fileName){
		if(ResourceManager.getInstance().isSdcardReady()){
			String filePath=SD_IMG_PATH+fileName;
			String folder=getFolderFromPath(filePath);
			ResourceManager.getInstance().mkSdcardFileDirs(folder);
			ResourceManager.getInstance().saveBitmap2Sdcard(bmp,filePath);
		}else{
			String filePath=ROM_IMG_PATH+fileName;
			String folder=getFolderFromPath(filePath);
			ResourceManager.getInstance().mkRomCacheDirs(context, folder);
			ResourceManager.getInstance().
			saveBitmap2RomCache(context, bmp, filePath);
		}
	}
	
	/**
	 * 获得图片文件
	 * @param context
	 * @param fileName
	 * @return
	 */
	public static Bitmap getBitmap(Context context,String fileName){
		if(ResourceManager.getInstance().isSdcardFileExist(SD_IMG_PATH+fileName)){
			return ResourceManager.getInstance().
			getBitmapFromSdcard(SD_IMG_PATH+fileName);
		}else if(ResourceManager.getInstance().isRomCacheFileExist(context, ROM_IMG_PATH+fileName)){
			return ResourceManager.getInstance().
			getBitmapFromRomCache(context,ROM_IMG_PATH+fileName);
		}
		return null;
	}
	
}