/*
* Copyright (C) 2007 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.camera;
import java.util.ArrayList;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.Rect;
import android.net.Uri;
import android.util.Config;
import android.util.Log;
class ImageLoader {
private static final String TAG = "ImageLoader";
// queue of work to do in the worker thread
private ArrayList<WorkItem> mQueue = new ArrayList<WorkItem>();
private ArrayList<WorkItem> mInProgress = new ArrayList<WorkItem>();
// the worker thread and a done flag so we know when to exit
// currently we only exit from finalize
private boolean mDone;
private ArrayList<Thread> mDecodeThreads = new ArrayList<Thread>();
private android.os.Handler mHandler;
private int mThreadCount = 1;
synchronized void clear(Uri uri) {
}
synchronized public void dump() {
synchronized (mQueue) {
if (Config.LOGV)
Log.v(TAG, "Loader queue length is " + mQueue.size());
}
}
public interface LoadedCallback {
public void run(Bitmap result);
}
public void pushToFront(final ImageManager.IImage image) {
synchronized (mQueue) {
WorkItem w = new WorkItem(image, 0, null, false);
int existing = mQueue.indexOf(w);
if (existing >= 1) {
WorkItem existingWorkItem = mQueue.remove(existing);
mQueue.add(0, existingWorkItem);
mQueue.notifyAll();
}
}
}
public boolean cancel(final ImageManager.IImage image) {
synchronized (mQueue) {
WorkItem w = new WorkItem(image, 0, null, false);
int existing = mQueue.indexOf(w);
if (existing >= 0) {
mQueue.remove(existing);
return true;
}
return false;
}
}
public Bitmap getBitmap(final ImageManager.IImage image, final LoadedCallback imageLoadedRunnable, final boolean postAtFront, boolean postBack) {
return getBitmap(image, 0, imageLoadedRunnable, postAtFront, postBack);
}
public Bitmap getBitmap(final ImageManager.IImage image, int tag, final LoadedCallback imageLoadedRunnable, final boolean postAtFront, boolean postBack) {
synchronized (mDecodeThreads) {
if (mDecodeThreads.size() == 0) {
start();
}
}
long t1 = System.currentTimeMillis();
long t2,t3,t4;
synchronized (mQueue) {
t2 = System.currentTimeMillis();
WorkItem w = new WorkItem(image, tag, imageLoadedRunnable, postBack);
if (!mInProgress.contains(w)) {
boolean contains = mQueue.contains(w);
if (contains) {
if (postAtFront) {
// move this item to the front
mQueue.remove(w);
mQueue.add(0, w);
}
} else {
if (postAtFront)
mQueue.add(0, w);
else
mQueue.add(w);
mQueue.notifyAll();
}
}
if (false)
dumpQueue("+" + (postAtFront ? "F " : "B ") + tag + ": ");
t3 = System.currentTimeMillis();
}
t4 = System.currentTimeMillis();
// Log.v(TAG, "getBitmap breakdown: tot= " + (t4-t1) + "; " + "; " + (t4-t3) + "; " + (t3-t2) + "; " + (t2-t1));
return null;
}
private void dumpQueue(String s) {
synchronized (mQueue) {
StringBuilder sb = new StringBuilder(s);
for (int i = 0; i < mQueue.size(); i++) {
sb.append(mQueue.get(i).mTag + " ");
}
if (Config.LOGV)
Log.v(TAG, sb.toString());
}
}
long bitmapSize(Bitmap b) {
return b.getWidth() * b.getHeight() * 4;
}
class WorkItem {
ImageManager.IImage mImage;
int mTargetX, mTargetY;
int mTag;
LoadedCallback mOnLoadedRunnable;
boolean mPostBack;
WorkItem(ImageManager.IImage image, int tag, LoadedCallback onLoadedRunnable, boolean postBack) {
mImage = image;
mTag = tag;
mOnLoadedRunnable = onLoadedRunnable;
mPostBack = postBack;
}
public boolean equals(Object other) {
WorkItem otherWorkItem = (WorkItem) other;
if (otherWorkItem.mImage != mImage)
return false;
return true;
}
public int hashCode() {
return mImage.fullSizeImageUri().hashCode();
}
}
public ImageLoader(android.os.Handler handler, int threadCount) {
mThreadCount = threadCount;
mHandler = handler;
start();
}
synchronized private void start() {
if (Config.LOGV)
Log.v(TAG, "ImageLoader.start() <<<<<<<<<<<<<<<<<<<<<<<<<<<<");
synchronized (mDecodeThreads) {
if (mDecodeThreads.size() > 0)
return;
mDone = false;
for (int i = 0;i < mThreadCount; i++) {
Thread t = new Thread(new Runnable() {
// pick off items on the queue, one by one, and compute their bitmap.
// place the resulting bitmap in the cache. then post a notification
// back to the ui so things can get updated appropriately.
public void run() {
while (!mDone) {
WorkItem workItem = null;
synchronized (mQueue) {
if (mQueue.size() > 0) {
workItem = mQueue.remove(0);
mInProgress.add(workItem);
}
else {
try {
mQueue.wait();
} catch (InterruptedException ex) {
}
}
}
if (workItem != null) {
if (false)
dumpQueue("-" + workItem.mTag + ": ");
Bitmap b = null;
try {
b = workItem.mImage.miniThumbBitmap();
} catch (Exception ex) {
if (Config.LOGV) Log.v(TAG, "couldn't load miniThumbBitmap " + ex.toString());
// sd card removal or sd card full
}
if (b == null) {
if (Config.LOGV) Log.v(TAG, "unable to read thumbnail for " + workItem.mImage.fullSizeImageUri());
}
synchronized (mQueue) {
mInProgress.remove(workItem);
}
if (workItem.mOnLoadedRunnable != null) {
if (workItem.mPostBack) {
final WorkItem w1 = workItem;
final Bitmap bitmap = b;
if (!mDone) {
mHandler.post(new Runnable() {
public void run() {
w1.mOnLoadedRunnable.run(bitmap);
}
});
}
} else {
workItem.mOnLoadedRunnable.run(b);
}
}
}
}
}
});
t.setName("image-loader-" + i);
mDecodeThreads.add(t);
t.start();
}
}
}
public static Bitmap transform(Matrix scaler, Bitmap source, int targetWidth, int targetHeight,
boolean scaleUp) {
int deltaX = source.getWidth() - targetWidth;
int deltaY = source.getHeight() - targetHeight;
if (!scaleUp && (deltaX < 0 || deltaY < 0)) {
/*
* In this case the bitmap is smaller, at least in one dimension, than the
* target. Transform it by placing as much of the image as possible into
* the target and leaving the top/bottom or left/right (or both) black.
*/
Bitmap b2 = Bitmap.createBitmap(targetWidth, targetHeight, Bitmap.Config.ARGB_8888);
Canvas c = new Canvas(b2);
int deltaXHalf = Math.max(0, deltaX/2);
int deltaYHalf = Math.max(0, deltaY/2);
Rect src = new Rect(
deltaXHalf,
deltaYHalf,
deltaXHalf + Math.min(targetWidth, source.getWidth()),
deltaYHalf + Math.min(targetHeight, source.getHeight()));
int dstX = (targetWidth - src.width()) / 2;
int dstY = (targetHeight - src.height()) / 2;
Rect dst = new Rect(
dstX,
dstY,
targetWidth - dstX,
targetHeight - dstY);
if (Config.LOGV)
Log.v(TAG, "draw " + src.toString() + " ==> " + dst.toString());
c.drawBitmap(source, src, dst, null);
return b2;
}
float bitmapWidthF = source.getWidth();
float bitmapHeightF = source.getHeight();
float bitmapAspect = bitmapWidthF / bitmapHeightF;
float viewAspect = (float) targetWidth / (float) targetHeight;
if (bitmapAspect > viewAspect) {
float scale = targetHeight / bitmapHeightF;
if (scale < .9F || scale > 1F) {
scaler.setScale(scale, scale);
} else {
scaler = null;
}
} else {
float scale = targetWidth / bitmapWidthF;
if (scale < .9F || scale > 1F) {
scaler.setScale(scale, scale);
} else {
scaler = null;
}
}
Bitmap b1;
if (scaler != null) {
// this is used for minithumb and crop, so we want to filter here.
b1 = Bitmap.createBitmap(source, 0, 0,
source.getWidth(), source.getHeight(), scaler, true);
} else {
b1 = source;
}
int dx1 = Math.max(0, b1.getWidth() - targetWidth);
int dy1 = Math.max(0, b1.getHeight() - targetHeight);
Bitmap b2 = Bitmap.createBitmap(
b1,
dx1/2,
dy1/2,
targetWidth,
targetHeight);
if (b1 != source)
b1.recycle();
return b2;
}
public void stop() {
if (Config.LOGV)
Log.v(TAG, "ImageLoader.stop " + mDecodeThreads.size() + " threads");
mDone = true;
synchronized (mQueue) {
mQueue.notifyAll();
}
while (mDecodeThreads.size() > 0) {
Thread t = mDecodeThreads.get(0);
try {
t.join();
mDecodeThreads.remove(0);
} catch (InterruptedException ex) {
// so now what?
}
}
}
}
|
