Links
Android Sites
Language
Results
Loading...
1
/*
2
* Copyright (C) 2012 The Android Open Source Project
3
*
4
* Licensed under the Apache License, Version 2.0 (the "License");
5
* you may not use this file except in compliance with the License.
6
* You may obtain a copy of the License at
7
*
8
* http://www.apache.org/licenses/LICENSE-2.0
9
*
10
* Unless required by applicable law or agreed to in writing, software
11
* distributed under the License is distributed on an "AS IS" BASIS,
12
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
* See the License for the specific language governing permissions and
14
* limitations under the License.
15
*/
16
17
package com.example.android.displayingbitmaps.util;
18
19
import android.annotation.TargetApi;
20
import android.content.Context;
21
import android.content.res.Resources;
22
import android.graphics.Bitmap;
23
import android.graphics.BitmapFactory;
24
import android.os.Build;
25
26
import com.example.android.common.logger.Log;
27
import com.example.android.displayingbitmaps.BuildConfig;
28
29
import java.io.FileDescriptor;
30
31
/**
32
* A simple subclass of {@link ImageWorker} that resizes images from resources given a target width
33
* and height. Useful for when the input images might be too large to simply load directly into
34
* memory.
35
*/
36
public class ImageResizer extends ImageWorker {
37
private static final String TAG = "ImageResizer";
38
protected int mImageWidth;
39
protected int mImageHeight;
40
41
/**
42
* Initialize providing a single target image size (used for both width and height);
43
*
44
* @param context
45
* @param imageWidth
46
* @param imageHeight
47
*/
48
public ImageResizer(Context context, int imageWidth, int imageHeight) {
49
super(context);
50
setImageSize(imageWidth, imageHeight);
51
}
52
53
/**
54
* Initialize providing a single target image size (used for both width and height);
55
*
56
* @param context
57
* @param imageSize
58
*/
59
public ImageResizer(Context context, int imageSize) {
60
super(context);
61
setImageSize(imageSize);
62
}
63
64
/**
65
* Set the target image width and height.
66
*
67
* @param width
68
* @param height
69
*/
70
public void setImageSize(int width, int height) {
71
mImageWidth = width;
72
mImageHeight = height;
73
}
74
75
/**
76
* Set the target image size (width and height will be the same).
77
*
78
* @param size
79
*/
80
public void setImageSize(int size) {
81
setImageSize(size, size);
82
}
83
84
/**
85
* The main processing method. This happens in a background task. In this case we are just
86
* sampling down the bitmap and returning it from a resource.
87
*
88
* @param resId
89
* @return
90
*/
91
private Bitmap processBitmap(int resId) {
92
if (BuildConfig.DEBUG) {
93
Log.d(TAG, "processBitmap - " + resId);
94
}
95
return decodeSampledBitmapFromResource(mResources, resId, mImageWidth,
96
mImageHeight, getImageCache());
97
}
98
99
@Override
100
protected Bitmap processBitmap(Object data) {
101
return processBitmap(Integer.parseInt(String.valueOf(data)));
102
}
103
104
/**
105
* Decode and sample down a bitmap from resources to the requested width and height.
106
*
107
* @param res The resources object containing the image data
108
* @param resId The resource id of the image data
109
* @param reqWidth The requested width of the resulting bitmap
110
* @param reqHeight The requested height of the resulting bitmap
111
* @param cache The ImageCache used to find candidate bitmaps for use with inBitmap
112
* @return A bitmap sampled down from the original with the same aspect ratio and dimensions
113
* that are equal to or greater than the requested width and height
114
*/
115
public static Bitmap decodeSampledBitmapFromResource(Resources res, int resId,
116
int reqWidth, int reqHeight, ImageCache cache) {
117
119
// First decode with inJustDecodeBounds=true to check dimensions
120
final BitmapFactory.Options options = new BitmapFactory.Options();
121
options.inJustDecodeBounds = true;
122
BitmapFactory.decodeResource(res, resId, options);
123
124
// Calculate inSampleSize
125
options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);
127
128
// If we're running on Honeycomb or newer, try to use inBitmap
129
if (Utils.hasHoneycomb()) {
130
addInBitmapOptions(options, cache);
131
}
132
133
// Decode bitmap with inSampleSize set
134
options.inJustDecodeBounds = false;
135
return BitmapFactory.decodeResource(res, resId, options);
136
}
137
138
/**
139
* Decode and sample down a bitmap from a file to the requested width and height.
140
*
141
* @param filename The full path of the file to decode
142
* @param reqWidth The requested width of the resulting bitmap
143
* @param reqHeight The requested height of the resulting bitmap
144
* @param cache The ImageCache used to find candidate bitmaps for use with inBitmap
145
* @return A bitmap sampled down from the original with the same aspect ratio and dimensions
146
* that are equal to or greater than the requested width and height
147
*/
148
public static Bitmap decodeSampledBitmapFromFile(String filename,
149
int reqWidth, int reqHeight, ImageCache cache) {
150
151
// First decode with inJustDecodeBounds=true to check dimensions
152
final BitmapFactory.Options options = new BitmapFactory.Options();
153
options.inJustDecodeBounds = true;
154
BitmapFactory.decodeFile(filename, options);
155
156
// Calculate inSampleSize
157
options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);
158
159
// If we're running on Honeycomb or newer, try to use inBitmap
160
if (Utils.hasHoneycomb()) {
161
addInBitmapOptions(options, cache);
162
}
163
164
// Decode bitmap with inSampleSize set
165
options.inJustDecodeBounds = false;
166
return BitmapFactory.decodeFile(filename, options);
167
}
168
169
/**
170
* Decode and sample down a bitmap from a file input stream to the requested width and height.
171
*
172
* @param fileDescriptor The file descriptor to read from
173
* @param reqWidth The requested width of the resulting bitmap
174
* @param reqHeight The requested height of the resulting bitmap
175
* @param cache The ImageCache used to find candidate bitmaps for use with inBitmap
176
* @return A bitmap sampled down from the original with the same aspect ratio and dimensions
177
* that are equal to or greater than the requested width and height
178
*/
179
public static Bitmap decodeSampledBitmapFromDescriptor(
180
FileDescriptor fileDescriptor, int reqWidth, int reqHeight, ImageCache cache) {
181
182
// First decode with inJustDecodeBounds=true to check dimensions
183
final BitmapFactory.Options options = new BitmapFactory.Options();
184
options.inJustDecodeBounds = true;
185
BitmapFactory.decodeFileDescriptor(fileDescriptor, null, options);
186
187
// Calculate inSampleSize
188
options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);
189
190
// Decode bitmap with inSampleSize set
191
options.inJustDecodeBounds = false;
192
193
// If we're running on Honeycomb or newer, try to use inBitmap
194
if (Utils.hasHoneycomb()) {
195
addInBitmapOptions(options, cache);
196
}
197
198
return BitmapFactory.decodeFileDescriptor(fileDescriptor, null, options);
199
}
200
201
@TargetApi(Build.VERSION_CODES.HONEYCOMB)
202
private static void addInBitmapOptions(BitmapFactory.Options options, ImageCache cache) {
204
// inBitmap only works with mutable bitmaps so force the decoder to
205
// return mutable bitmaps.
206
options.inMutable = true;
207
208
if (cache != null) {
209
// Try and find a bitmap to use for inBitmap
210
Bitmap inBitmap = cache.getBitmapFromReusableSet(options);
211
212
if (inBitmap != null) {
213
options.inBitmap = inBitmap;
214
}
215
}
217
}
218
219
/**
220
* Calculate an inSampleSize for use in a {@link android.graphics.BitmapFactory.Options} object when decoding
221
* bitmaps using the decode* methods from {@link android.graphics.BitmapFactory}. This implementation calculates
222
* the closest inSampleSize that is a power of 2 and will result in the final decoded bitmap
223
* having a width and height equal to or larger than the requested width and height.
224
*
225
* @param options An options object with out* params already populated (run through a decode*
226
* method with inJustDecodeBounds==true
227
* @param reqWidth The requested width of the resulting bitmap
228
* @param reqHeight The requested height of the resulting bitmap
229
* @return The value to be used for inSampleSize
230
*/
231
public static int calculateInSampleSize(BitmapFactory.Options options,
232
int reqWidth, int reqHeight) {
234
// Raw height and width of image
235
final int height = options.outHeight;
236
final int width = options.outWidth;
237
int inSampleSize = 1;
238
239
if (height > reqHeight || width > reqWidth) {
240
241
final int halfHeight = height / 2;
242
final int halfWidth = width / 2;
243
244
// Calculate the largest inSampleSize value that is a power of 2 and keeps both
245
// height and width larger than the requested height and width.
246
while ((halfHeight / inSampleSize) > reqHeight
247
&& (halfWidth / inSampleSize) > reqWidth) {
248
inSampleSize *= 2;
249
}
250
251
// This offers some additional logic in case the image has a strange
252
// aspect ratio. For example, a panorama may have a much larger
253
// width than height. In these cases the total pixels might still
254
// end up being too large to fit comfortably in memory, so we should
255
// be more aggressive with sample down the image (=larger inSampleSize).
256
257
long totalPixels = width * height / inSampleSize;
258
259
// Anything more than 2x the requested pixels we'll sample down further
260
final long totalReqPixelsCap = reqWidth * reqHeight * 2;
261
262
while (totalPixels > totalReqPixelsCap) {
263
inSampleSize *= 2;
264
totalPixels /= 2;
265
}
266
}
267
return inSampleSize;
269
}
270
}