Android--生成缩略图------方法总结

在Android中对大图片进行缩放真的很不尽如人意，不知道是不是我的方法不对。下面我列出3种对图片缩放的方法，并给出相应速度。请高人指教。

第一种是BitmapFactory和BitmapFactory.Options。
首先，BitmapFactory.Options有几个Fields很有用：
inJustDecodeBounds：If set to true, the decoder will return null (no bitmap), but the out...
也就是说，当inJustDecodeBounds设成true时，bitmap并不加载到内存，这样效率很高哦。而这时，你可以获得bitmap的高、宽等信息。
outHeight：The resulting height of the bitmap, set independent of the state of inJustDecodeBounds.
outWidth：The resulting width of the bitmap, set independent of the state of inJustDecodeBounds.
看到了吧，上面3个变量是相关联的哦。
inSampleSize ： If set to a value > 1, requests the decoder to subsample the original image, returning a smaller image to save memory.
这就是用来做缩放比的。这里有个技巧：
inSampleSize=（outHeight/Height+outWidth/Width）/2
实践证明，这样缩放出来的图片还是很好的。
最后用BitmapFactory.decodeFile(path, options)生成。
由于只是对bitmap加载到内存一次，所以效率比较高。解析速度快。

第二种是使用Bitmap加Matrix来缩放。

首先要获得原bitmap，再从原bitmap的基础上生成新图片。这样效率很低。

第三种是用2.2新加的类ThumbnailUtils来做。
让我们新看看这个类，从API中来看，此类就三个静态方法：createVideoThumbnail、extractThumbnail(Bitmap source, int width, int height, int options)、extractThumbnail(Bitmap source, int width, int height)。
我这里使用了第三个方法。再看看它的源码，下面会附上。是上面我们用到的BitmapFactory.Options和Matrix等经过人家一阵加工而成。
效率好像比第二种方法高一点点。

下面是我的例子：

 

[html]view plaincopy

2.  
3. android:layout_width="fill_parent"
4. android:layout_height="fill_parent"
5. >
6.  
7. <>
8. android:id="@+id/imageShow"
10. android:layout_width="wrap_content"
11. android:layout_height="wrap_content"
12. />
13. <>
14. android:id="@+id/image2"
16. android:layout_width="wrap_content"
17. android:layout_height="wrap_content"
18. />
19. <>
20. android:id="@+id/text"
22. android:layout_width="fill_parent"
23. android:layout_height="wrap_content"
24. android:text="@string/hello"
25. />
26. 
    [java]view plaincopy
     
    1. packagecom.linc.ResolvePicture;
    2.  
    3. importjava.io.File;
    4. importjava.io.FileNotFoundException;
    5. importjava.io.FileOutputStream;
    6. importjava.io.IOException;
    7.  
    8. importandroid.app.Activity;
    9. importandroid.graphics.Bitmap;
    10. importandroid.graphics.BitmapFactory;
    11. importandroid.graphics.Matrix;
    12. importandroid.graphics.drawable.BitmapDrawable;
    13. importandroid.graphics.drawable.Drawable;
    14. importandroid.media.ThumbnailUtils;
    15. importandroid.os.Bundle;
    16. importandroid.util.Log;
    17. importandroid.widget.ImageView;
    18. importandroid.widget.TextView;
    19.  
    20. publicclassResolvePictureextendsActivity{
    21. privatestaticStringtag="ResolvePicture";
    22. DrawablebmImg;
    23. ImageViewimView;
    24. ImageViewimView2;
    25. TextViewtext;
    26. StringtheTime;
    27. longstart,stop;
    28. /**Calledwhentheactivityisfirstcreated.*/
    29. @Override
    30. publicvoidonCreate(BundlesavedInstanceState){
    31. super.onCreate(savedInstanceState);
    32. setContentView(R.layout.main);
    33.  
    34. text=(TextView)findViewById(R.id.text);
    35.  
    36. imView=(ImageView)findViewById(R.id.imageShow);
    37. imView2=(ImageView)findViewById(R.id.image2);
    38.  
    39. Bitmapbitmap=BitmapFactory.decodeResource(getResources(),
    40. R.drawable.pic);
    41.  
    42. start=System.currentTimeMillis();
    43.  
    44. //imView.setImageDrawable(resizeImage(bitmap,300,100));
    45.  
    46. imView2.setImageDrawable(resizeImage2("/sdcard/2.jpeg",200,100));
    47.  
    48. stop=System.currentTimeMillis();
    49.  
    50. StringtheTime=String.format("\n1iterative:(%dmsec)",
    51. stop-start);
    52.  
    53. start=System.currentTimeMillis();
    54. imView.setImageBitmap(ThumbnailUtils.extractThumbnail(bitmap,200,100));//2.2才加进来的新类，简单易用
    55. //imView.setImageDrawable(resizeImage(bitmap,30,30));
    56. stop=System.currentTimeMillis();
    57.  
    58. theTime+=String.format("\n2iterative:(%dmsec)",
    59. stop-start);
    60.  
    61. text.setText(theTime);
    62. }
    63.  
    64. //使用Bitmap加Matrix来缩放
    65. publicstaticDrawableresizeImage(Bitmapbitmap,intw,inth)
    66. {
    67. BitmapBitmapOrg=bitmap;
    68. intwidth=BitmapOrg.getWidth();
    69. intheight=BitmapOrg.getHeight();
    70. intnewWidth=w;
    71. intnewHeight=h;
    72.  
    73. floatscaleWidth=((float)newWidth)/width;
    74. floatscaleHeight=((float)newHeight)/height;
    75.  
    76. Matrixmatrix=newMatrix();
    77. matrix.postScale(scaleWidth,scaleHeight);
    78. //ifyouwanttorotatetheBitmap
    79. //matrix.postRotate(45);
    80. BitmapresizedBitmap=Bitmap.createBitmap(BitmapOrg,0,0,width,
    81. height,matrix,true);
    82. returnnewBitmapDrawable(resizedBitmap);
    83. }
    84.  
    85. //使用BitmapFactory.Options的inSampleSize参数来缩放
    86. publicstaticDrawableresizeImage2(Stringpath,
    87. intwidth,intheight)
    88. {
    89. BitmapFactory.Optionsoptions=newBitmapFactory.Options();
    90. options.inJustDecodeBounds=true;//不加载bitmap到内存中
    91. BitmapFactory.decodeFile(path,options);
    92. intoutWidth=options.outWidth;
    93. intoutHeight=options.outHeight;
    94. options.inDither=false;
    95. options.inPreferredConfig=Bitmap.Config.ARGB_8888;
    96. options.inSampleSize=1;
    97.  
    98. if(outWidth!=0&&outHeight!=0&&width!=0&&height!=0)
    99. {
    100. intsampleSize=(outWidth/width+outHeight/height)/2;
    101. Log.d(tag,"sampleSize="+sampleSize);
    102. options.inSampleSize=sampleSize;
    103. }
    104.  
    105. options.inJustDecodeBounds=false;
    106. returnnewBitmapDrawable(BitmapFactory.decodeFile(path,options));
    107. }
    108.  
    109. //图片保存
    110. privatevoidsaveThePicture(Bitmapbitmap)
    111. {
    112. Filefile=newFile("/sdcard/2.jpeg");
    113. try
    114. {
    115. FileOutputStreamfos=newFileOutputStream(file);
    116. if(bitmap.compress(Bitmap.CompressFormat.JPEG,100,fos))
    117. {
    118. fos.flush();
    119. fos.close();
    120. }
    121. }
    122. catch(FileNotFoundExceptione1)
    123. {
    124. e1.printStackTrace();
    125. }
    126. catch(IOExceptione2)
    127. {
    128. e2.printStackTrace();
    129. }
    130. }
    131. }

1. /*
2. *Copyright(C)2009TheAndroidOpenSourceProject
3. *
4. *LicensedundertheApacheLicense,Version2.0(the"License");
5. *youmaynotusethisfileexceptincompliancewiththeLicense.
6. *YoumayobtainacopyoftheLicenseat
7. *
8. *http://www.apache.org/licenses/LICENSE-2.0
9. *
10. *Unlessrequiredbyapplicablelaworagreedtoinwriting,software
11. *distributedundertheLicenseisdistributedonan"ASIS"BASIS,
12. *WITHOUTWARRANTIESORCONDITIONSOFANYKIND,eitherexpressorimplied.
13. *SeetheLicenseforthespecificlanguagegoverningpermissionsand
14. *limitationsundertheLicense.
15. */
16.  
17. packageandroid.media;
18.  
19. importandroid.content.ContentResolver;
20. importandroid.content.ContentUris;
21. importandroid.content.ContentValues;
22. importandroid.database.Cursor;
23. importandroid.graphics.Bitmap;
24. importandroid.graphics.BitmapFactory;
25. importandroid.graphics.Canvas;
26. importandroid.graphics.Matrix;
27. importandroid.graphics.Rect;
28. importandroid.media.MediaMetadataRetriever;
29. importandroid.media.MediaFile.MediaFileType;
30. importandroid.net.Uri;
31. importandroid.os.ParcelFileDescriptor;
32. importandroid.provider.BaseColumns;
33. importandroid.provider.MediaStore.Images;
34. importandroid.provider.MediaStore.Images.Thumbnails;
35. importandroid.util.Log;
36.  
37. importjava.io.FileInputStream;
38. importjava.io.FileDescriptor;
39. importjava.io.IOException;
40. importjava.io.OutputStream;
41.  
42. /**
43. *Thumbnailgenerationroutinesformediaprovider.
44. */
45.  
46. publicclassThumbnailUtils{
47. privatestaticfinalStringTAG="ThumbnailUtils";
48.  
49. /*Maximumpixelssizeforcreatedbitmap.*/
50. privatestaticfinalintMAX_NUM_PIXELS_THUMBNAIL=512*384;
51. privatestaticfinalintMAX_NUM_PIXELS_MICRO_THUMBNAIL=128*128;
52. privatestaticfinalintUNCONSTRAINED=-1;
53.  
54. /*Optionsusedinternally.*/
55. privatestaticfinalintOPTIONS_NONE=0x0;
56. privatestaticfinalintOPTIONS_SCALE_UP=0x1;
57.  
58. /**
59. *Constantusedtoindicateweshouldrecycletheinputin
60. *{@link#extractThumbnail(Bitmap,int,int,int)}unlesstheoutputistheinput.
61. */
62. publicstaticfinalintOPTIONS_RECYCLE_INPUT=0x2;
63.  
64. /**
65. *Constantusedtoindicatethedimensionofminithumbnail.
66. *@hideOnlyusedbymediaframeworkandmediaproviderinternally.
67. */
68. publicstaticfinalintTARGET_SIZE_MINI_THUMBNAIL=320;
69.  
70. /**
71. *Constantusedtoindicatethedimensionofmicrothumbnail.
72. *@hideOnlyusedbymediaframeworkandmediaproviderinternally.
73. */
74. publicstaticfinalintTARGET_SIZE_MICRO_THUMBNAIL=96;
75.  
76. /**
77. *ThismethodfirstexaminesifthethumbnailembeddedinEXIFisbiggerthanourtarget
78. *size.Ifnot,thenit'llcreateathumbnailfromoriginalimage.Duetoefficiency
79. *consideration,wewanttoletMediaThumbRequestavoidcallingthismethodtwicefor
80. *bothkinds,soitonlyrequestsforMICRO_KINDandsetsaveImagetotrue.
81. *
82. *Thismethodalwaysreturnsa"squarethumbnail"forMICRO_KINDthumbnail.
83. *
84. *@paramfilePaththepathofimagefile
85. *@paramkindcouldbeMINI_KINDorMICRO_KIND
86. *@returnBitmap
87. *
88. *@hideThismethodisonlyusedbymediaframeworkandmediaproviderinternally.
89. */
90. publicstaticBitmapcreateImageThumbnail(StringfilePath,intkind){
91. booleanwantMini=(kind==Images.Thumbnails.MINI_KIND);
92. inttargetSize=wantMini
93. ?TARGET_SIZE_MINI_THUMBNAIL
94. :TARGET_SIZE_MICRO_THUMBNAIL;
95. intmaxPixels=wantMini
96. ?MAX_NUM_PIXELS_THUMBNAIL
97. :MAX_NUM_PIXELS_MICRO_THUMBNAIL;
98. SizedThumbnailBitmapsizedThumbnailBitmap=newSizedThumbnailBitmap();
99. Bitmapbitmap=null;
100. MediaFileTypefileType=MediaFile.getFileType(filePath);
101. if(fileType!=null&&fileType.fileType==MediaFile.FILE_TYPE_JPEG){
102. createThumbnailFromEXIF(filePath,targetSize,maxPixels,sizedThumbnailBitmap);
103. bitmap=sizedThumbnailBitmap.mBitmap;
104. }
105.  
106. if(bitmap==null){
107. try{
108. FileDescriptorfd=newFileInputStream(filePath).getFD();
109. BitmapFactory.Optionsoptions=newBitmapFactory.Options();
110. options.inSampleSize=1;
111. options.inJustDecodeBounds=true;
112. BitmapFactory.decodeFileDescriptor(fd,null,options);
113. if(options.mCancel||options.outWidth==-1
114. ||options.outHeight==-1){
115. returnnull;
116. }
117. options.inSampleSize=computeSampleSize(
118. options,targetSize,maxPixels);
119. options.inJustDecodeBounds=false;
120.  
121. options.inDither=false;
122. options.inPreferredConfig=Bitmap.Config.ARGB_8888;
123. bitmap=BitmapFactory.decodeFileDescriptor(fd,null,options);
124. }catch(IOExceptionex){
125. Log.e(TAG,"",ex);
126. }
127. }
128.  
129. if(kind==Images.Thumbnails.MICRO_KIND){
130. //nowwemakeita"squarethumbnail"forMICRO_KINDthumbnail
131. bitmap=extractThumbnail(bitmap,
132. TARGET_SIZE_MICRO_THUMBNAIL,
133. TARGET_SIZE_MICRO_THUMBNAIL,OPTIONS_RECYCLE_INPUT);
134. }
135. returnbitmap;
136. }
137.  
138. /**
139. *Createavideothumbnailforavideo.Mayreturnnullifthevideois
140. *corruptortheformatisnotsupported.
141. *
142. *@paramfilePaththepathofvideofile
143. *@paramkindcouldbeMINI_KINDorMICRO_KIND
144. */
145. publicstaticBitmapcreateVideoThumbnail(StringfilePath,intkind){
146. Bitmapbitmap=null;
147. MediaMetadataRetrieverretriever=newMediaMetadataRetriever();
148. try{
149. retriever.setMode(MediaMetadataRetriever.MODE_CAPTURE_FRAME_ONLY);
150. retriever.setDataSource(filePath);
151. bitmap=retriever.captureFrame();
152. }catch(IllegalArgumentExceptionex){
153. //Assumethisisacorruptvideofile
154. }catch(RuntimeExceptionex){
155. //Assumethisisacorruptvideofile.
156. }finally{
157. try{
158. retriever.release();
159. }catch(RuntimeExceptionex){
160. //Ignorefailureswhilecleaningup.
161. }
162. }
163. if(kind==Images.Thumbnails.MICRO_KIND&&bitmap!=null){
164. bitmap=extractThumbnail(bitmap,
165. TARGET_SIZE_MICRO_THUMBNAIL,
166. TARGET_SIZE_MICRO_THUMBNAIL,
167. OPTIONS_RECYCLE_INPUT);
168. }
169. returnbitmap;
170. }
171.  
172. /**
173. *Createsacenteredbitmapofthedesiredsize.
174. *
175. *@paramsourceoriginalbitmapsource
176. *@paramwidthtargetedwidth
177. *@paramheighttargetedheight
178. */
179. publicstaticBitmapextractThumbnail(
180. Bitmapsource,intwidth,intheight){
181. returnextractThumbnail(source,width,height,OPTIONS_NONE);
182. }
183.  
184. /**
185. *Createsacenteredbitmapofthedesiredsize.
186. *
187. *@paramsourceoriginalbitmapsource
188. *@paramwidthtargetedwidth
189. *@paramheighttargetedheight
190. *@paramoptionsoptionsusedduringthumbnailextraction
191. */
192. publicstaticBitmapextractThumbnail(
193. Bitmapsource,intwidth,intheight,intoptions){
194. if(source==null){
195. returnnull;
196. }
197.  
198. floatscale;
199. if(source.getWidth()<>
200. scale=width/(float)source.getWidth();
202. }else{
203. scale=height/(float)source.getHeight();
204. }
205. Matrixmatrix=newMatrix();
206. matrix.setScale(scale,scale);
207. Bitmapthumbnail=transform(matrix,source,width,height,
208. OPTIONS_SCALE_UP|options);
209. returnthumbnail;
210. }
211.  
212. /*
213. *ComputethesamplesizeasafunctionofminSideLength
214. *andmaxNumOfPixels.
215. *minSideLengthisusedtospecifythatminimalwidthorheightofa
216. *bitmap.
217. *maxNumOfPixelsisusedtospecifythemaximalsizeinpixelsthatis
218. *tolerableintermsofmemoryusage.
219. *
220. *Thefunctionreturnsasamplesizebasedontheconstraints.
221. *BothsizeandminSideLengthcanbepassedinasIImage.UNCONSTRAINED,
222. *whichindicatesnocareofthecorrespondingconstraint.
223. *Thefunctionsprefersreturningasamplesizethat
224. *generatesasmallerbitmap,unlessminSideLength=IImage.UNCONSTRAINED.
225. *
226. *Also,thefunctionroundsupthesamplesizetoapowerof2ormultiple
227. *of8becauseBitmapFactoryonlyhonorssamplesizethisway.
228. *Forexample,BitmapFactorydownsamplesanimageby2eventhoughthe
229. *requestis3.SoweroundupthesamplesizetoavoidOOM.
230. */
231. privatestaticintcomputeSampleSize(BitmapFactory.Optionsoptions,
232. intminSideLength,intmaxNumOfPixels){
233. intinitialSize=computeInitialSampleSize(options,minSideLength,
234. maxNumOfPixels);
235.  
236. introundedSize;
237. if(initialSize<=8){
238. roundedSize=1;
239. while(roundedSize<>
240. roundedSize<<=1;
242. }
243. }else{
244. roundedSize=(initialSize+7)/8*8;
245. }
246.  
247. returnroundedSize;
248. }
249.  
250. privatestaticintcomputeInitialSampleSize(BitmapFactory.Optionsoptions,
251. intminSideLength,intmaxNumOfPixels){
252. doublew=options.outWidth;
253. doubleh=options.outHeight;
254.  
255. intlowerBound=(maxNumOfPixels==UNCONSTRAINED)?1:
256. (int)Math.ceil(Math.sqrt(w*h/maxNumOfPixels));
257. intupperBound=(minSideLength==UNCONSTRAINED)?128:
258. (int)Math.min(Math.floor(w/minSideLength),
259. Math.floor(h/minSideLength));
260.  
261. if(upperBound<>
262. //returnthelargeronewhenthereisnooverlappingzone.
264. returnlowerBound;
265. }
266.  
267. if((maxNumOfPixels==UNCONSTRAINED)&&
268. (minSideLength==UNCONSTRAINED)){
269. return1;
270. }elseif(minSideLength==UNCONSTRAINED){
271. returnlowerBound;
272. }else{
273. returnupperBound;
274. }
275. }
276.  
277. /**
278. *MakeabitmapfromagivenUri,minimalsidelength,andmaximumnumberofpixels.
279. *Theimagedatawillbereadfromspecifiedpfdifit'snotnull,otherwise
280. *anewinputstreamwillbecreatedusingspecifiedContentResolver.
281. *
282. *ClientsareallowedtopasstheirownBitmapFactory.Optionsusedforbitmapdecoding.A
283. *newBitmapFactory.Optionswillbecreatedifoptionsisnull.
284. */
285. privatestaticBitmapmakeBitmap(intminSideLength,intmaxNumOfPixels,
286. Uriuri,ContentResolvercr,ParcelFileDescriptorpfd,
287. BitmapFactory.Optionsoptions){
288. Bitmapb=null;
289. try{
290. if(pfd==null)pfd=makeInputStream(uri,cr);
291. if(pfd==null)returnnull;
292. if(options==null)options=newBitmapFactory.Options();
293.  
294. FileDescriptorfd=pfd.getFileDescriptor();
295. options.inSampleSize=1;
296. options.inJustDecodeBounds=true;
297. BitmapFactory.decodeFileDescriptor(fd,null,options);
298. if(options.mCancel||options.outWidth==-1
299. ||options.outHeight==-1){
300. returnnull;
301. }
302. options.inSampleSize=computeSampleSize(
303. options,minSideLength,maxNumOfPixels);
304. options.inJustDecodeBounds=false;
305.  
306. options.inDither=false;
307. options.inPreferredConfig=Bitmap.Config.ARGB_8888;
308. b=BitmapFactory.decodeFileDescriptor(fd,null,options);
309. }catch(OutOfMemoryErrorex){
310. Log.e(TAG,"Gotoomexception",ex);
311. returnnull;
312. }finally{
313. closeSilently(pfd);
314. }
315. returnb;
316. }
317.  
318. privatestaticvoidcloseSilently(ParcelFileDescriptorc){
319. if(c==null)return;
320. try{
321. c.close();
322. }catch(Throwablet){
323. //donothing
324. }
325. }
326.  
327. privatestaticParcelFileDescriptormakeInputStream(
328. Uriuri,ContentResolvercr){
329. try{
330. returncr.openFileDescriptor(uri,"r");
331. }catch(IOExceptionex){
332. returnnull;
333. }
334. }
335.  
336. /**
337. *TransformsourceBitmaptotargetedwidthandheight.
338. */
339. privatestaticBitmaptransform(Matrixscaler,
340. Bitmapsource,
341. inttargetWidth,
342. inttargetHeight,
343. intoptions){
344. booleanscaleUp=(options&OPTIONS_SCALE_UP)!=0;
345. booleanrecycle=(options&OPTIONS_RECYCLE_INPUT)!=0;
346.  
347. intdeltaX=source.getWidth()-targetWidth;
348. intdeltaY=source.getHeight()-targetHeight;
349. if(!scaleUp&&(deltaX<0||deltaY<0)){
350. /*
351. *Inthiscasethebitmapissmaller,atleastinonedimension,
352. *thanthetarget.Transformitbyplacingasmuchoftheimage
353. *aspossibleintothetargetandleavingthetop/bottomor
354. *left/right(orboth)black.
355. */
356. Bitmapb2=Bitmap.createBitmap(targetWidth,targetHeight,
357. Bitmap.Config.ARGB_8888);
358. Canvasc=newCanvas(b2);
359.  
360. intdeltaXHalf=Math.max(0,deltaX/2);
361. intdeltaYHalf=Math.max(0,deltaY/2);
362. Rectsrc=newRect(
363. deltaXHalf,
364. deltaYHalf,
365. deltaXHalf+Math.min(targetWidth,source.getWidth()),
366. deltaYHalf+Math.min(targetHeight,source.getHeight()));
367. intdstX=(targetWidth-src.width())/2;
368. intdstY=(targetHeight-src.height())/2;
369. Rectdst=newRect(
370. dstX,
371. dstY,
372. targetWidth-dstX,
373. targetHeight-dstY);
374. c.drawBitmap(source,src,dst,null);
375. if(recycle){
376. source.recycle();
377. }
378. returnb2;
379. }
380. floatbitmapWidthF=source.getWidth();
381. floatbitmapHeightF=source.getHeight();
382.  
383. floatbitmapAspect=bitmapWidthF/bitmapHeightF;
384. floatviewAspect=(float)targetWidth/targetHeight;
385.  
386. if(bitmapAspect>viewAspect){
387. floatscale=targetHeight/bitmapHeightF;
388. if(scale<.9F||scale>1F){
389. scaler.setScale(scale,scale);
390. }else{
391. scaler=null;
392. }
393. }else{
394. floatscale=targetWidth/bitmapWidthF;
395. if(scale<.9F||scale>1F){
396. scaler.setScale(scale,scale);
397. }else{
398. scaler=null;
399. }
400. }
401.  
402. Bitmapb1;
403. if(scaler!=null){
404. //thisisusedforminithumbandcrop,sowewanttofilterhere.
405. b1=Bitmap.createBitmap(source,0,0,
406. source.getWidth(),source.getHeight(),scaler,true);
407. }else{
408. b1=source;
409. }
410.  
411. if(recycle&&b1!=source){
412. source.recycle();
413. }
414.  
415. intdx1=Math.max(0,b1.getWidth()-targetWidth);
416. intdy1=Math.max(0,b1.getHeight()-targetHeight);
417.  
418. Bitmapb2=Bitmap.createBitmap(
419. b1,
420. dx1/2,
421. dy1/2,
422. targetWidth,
423. targetHeight);
424.  
425. if(b2!=b1){
426. if(recycle||b1!=source){
427. b1.recycle();
428. }
429. }
430.  
431. returnb2;
432. }
433.  
434. /**
435. *SizedThumbnailBitmapcontainsthebitmap,whichisdownsampledeitherfrom
436. *thethumbnailinexiforthefullimage.
437. *mThumbnailData,mThumbnailWidthandmThumbnailHeightaresettogetheronlyifmThumbnail
438. *isnotnull.
439. *
440. *Thewidth/heightofthesizedbitmapmaybedifferentfrommThumbnailWidth/mThumbnailHeight.
441. */
442. privatestaticclassSizedThumbnailBitmap{
443. publicbyte[]mThumbnailData;
444. publicBitmapmBitmap;
445. publicintmThumbnailWidth;
446. publicintmThumbnailHeight;
447. }
448.  
449. /**
450. *CreatesabitmapbyeitherdownsamplingfromthethumbnailinEXIForthefullimage.
451. *ThefunctionsreturnsaSizedThumbnailBitmap,
452. *whichcontainsadownsampledbitmapandthethumbnaildatainEXIFifexists.
453. */
454. privatestaticvoidcreateThumbnailFromEXIF(StringfilePath,inttargetSize,
455. intmaxPixels,SizedThumbnailBitmapsizedThumbBitmap){
456. if(filePath==null)return;
457.  
458. ExifInterfaceexif=null;
459. byte[]thumbData=null;
460. try{
461. exif=newExifInterface(filePath);
462. if(exif!=null){
463. thumbData=exif.getThumbnail();
464. }
465. }catch(IOExceptionex){
466. Log.w(TAG,ex);
467. }
468.  
469. BitmapFactory.OptionsfullOptions=newBitmapFactory.Options();
470. BitmapFactory.OptionsexifOptions=newBitmapFactory.Options();
471. intexifThumbWidth=0;
472. intfullThumbWidth=0;
473.  
474. //ComputeexifThumbWidth.
475. if(thumbData!=null){
476. exifOptions.inJustDecodeBounds=true;
477. BitmapFactory.decodeByteArray(thumbData,0,thumbData.length,exifOptions);
478. exifOptions.inSampleSize=computeSampleSize(exifOptions,targetSize,maxPixels);
479. exifThumbWidth=exifOptions.outWidth/exifOptions.inSampleSize;
480. }
481.  
482. //ComputefullThumbWidth.
483. fullOptions.inJustDecodeBounds=true;
484. BitmapFactory.decodeFile(filePath,fullOptions);
485. fullOptions.inSampleSize=computeSampleSize(fullOptions,targetSize,maxPixels);
486. fullThumbWidth=fullOptions.outWidth/fullOptions.inSampleSize;
487.  
488. //ChoosethelargerthumbnailasthereturningsizedThumbBitmap.
489. if(thumbData!=null&&exifThumbWidth>=fullThumbWidth){
490. intwidth=exifOptions.outWidth;
491. intheight=exifOptions.outHeight;
492. exifOptions.inJustDecodeBounds=false;
493. sizedThumbBitmap.mBitmap=BitmapFactory.decodeByteArray(thumbData,0,
494. thumbData.length,exifOptions);
495. if(sizedThumbBitmap.mBitmap!=null){
496. sizedThumbBitmap.mThumbnailData=thumbData;
497. sizedThumbBitmap.mThumbnailWidth=width;
498. sizedThumbBitmap.mThumbnailHeight=height;
499. }
500. }else{
501. fullOptions.inJustDecodeBounds=false;
502. sizedThumbBitmap.mBitmap=BitmapFactory.decodeFile(filePath,fullOptions);
503. }
504. }
505. }