src/com/android/camera/ImageGetter.java - platform/packages/apps/Gallery - Git at Google

 /*
  * Copyright (C) 2009 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 com.android.camera.gallery.IImage;
 import com.android.camera.gallery.IImageList;
 import com.android.camera.gallery.VideoObject;

 import android.content.ContentResolver;
 import android.graphics.Bitmap;
 import android.os.Handler;
 import android.os.Message;
 import android.os.Process;
 import android.provider.MediaStore;

 /*
  * Here's the loading strategy.  For any given image, load the thumbnail
  * into memory and post a callback to display the resulting bitmap.
  *
  * Then proceed to load the full image bitmap.   Three things can
  * happen at this point:
  *
  * 1.  the image fails to load because the UI thread decided
  * to move on to a different image.  This "cancellation" happens
  * by virtue of the UI thread closing the stream containing the
  * image being decoded.  BitmapFactory.decodeStream returns null
  * in this case.
  *
  * 2.  the image loaded successfully.  At that point we post
  * a callback to the UI thread to actually show the bitmap.
  *
  * 3.  when the post runs it checks to see if the image that was
  * loaded is still the one we want.  The UI may have moved on
  * to some other image and if so we just drop the newly loaded
  * bitmap on the floor.
  */

 interface ImageGetterCallback {
     public void imageLoaded(int pos, int offset, RotateBitmap bitmap,
                             boolean isThumb);
     public boolean wantsThumbnail(int pos, int offset);
     public boolean wantsFullImage(int pos, int offset);
     public int fullImageSizeToUse(int pos, int offset);
     public void completed();
     public int [] loadOrder();
 }

 class ImageGetter {

     @SuppressWarnings("unused")
     private static final String TAG = "ImageGetter";

     // The thread which does the work.
     private Thread mGetterThread;

     // The current request serial number.
     // This is increased by one each time a new job is assigned.
     // It is only written in the main thread.
     private int mCurrentSerial;

     // The base position that's being retrieved.  The actual images retrieved
     // are this base plus each of the offets. -1 means there is no current
     // request needs to be finished.
     private int mCurrentPosition = -1;

     // The callback to invoke for each image.
     private ImageGetterCallback mCB;

     // The image list for the images.
     private IImageList mImageList;

     // The handler to do callback.
     private GetterHandler mHandler;

     // True if we want to cancel the current loading.
     private volatile boolean mCancel = true;

     // True if the getter thread is idle waiting.
     private boolean mIdle = false;

     // True when the getter thread should exit.
     private boolean mDone = false;

     private ContentResolver mCr;

     private class ImageGetterRunnable implements Runnable {

         private Runnable callback(final int position, final int offset,
                                   final boolean isThumb,
                                   final RotateBitmap bitmap,
                                   final int requestSerial) {
             return new Runnable() {
                 public void run() {
                     // check for inflight callbacks that aren't applicable
                     // any longer before delivering them
                     if (requestSerial == mCurrentSerial) {
                         mCB.imageLoaded(position, offset, bitmap, isThumb);
                     } else if (bitmap != null) {
                         bitmap.recycle();
                     }
                 }
             };
         }

         private Runnable completedCallback(final int requestSerial) {
             return new Runnable() {
                 public void run() {
                     if (requestSerial == mCurrentSerial) {
                         mCB.completed();
                     }
                 }
             };
         }

         public void run() {
             // Lower the priority of this thread to avoid competing with
             // the UI thread.
             Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);

             while (true) {
                 synchronized (ImageGetter.this) {
                     while (mCancel || mDone || mCurrentPosition == -1) {
                         if (mDone) return;
                         mIdle = true;
                         ImageGetter.this.notify();
                         try {
                             ImageGetter.this.wait();
                         } catch (InterruptedException ex) {
                             // ignore
                         }
                         mIdle = false;
                     }
                 }

                 executeRequest();

                 synchronized (ImageGetter.this) {
                     mCurrentPosition = -1;
                 }
             }
         }
         private void executeRequest() {
             int imageCount = mImageList.getCount();

             int [] order = mCB.loadOrder();
             for (int i = 0; i < order.length; i++) {
                 if (mCancel) return;
                 int offset = order[i];
                 int imageNumber = mCurrentPosition + offset;
                 if (imageNumber >= 0 && imageNumber < imageCount) {
                     if (!mCB.wantsThumbnail(mCurrentPosition, offset)) {
                         continue;
                     }

                     IImage image = mImageList.getImageAt(imageNumber);
                     if (image == null) continue;
                     if (mCancel) return;

                     Bitmap b = image.thumbBitmap(IImage.NO_ROTATE);
                     if (b == null) continue;
                     if (mCancel) {
                         b.recycle();
                         return;
                     }

                     Runnable cb = callback(mCurrentPosition, offset,
                             true,
                             new RotateBitmap(b, image.getDegreesRotated()),
                             mCurrentSerial);
                     mHandler.postGetterCallback(cb);
                 }
             }

             for (int i = 0; i < order.length; i++) {
                 if (mCancel) return;
                 int offset = order[i];
                 int imageNumber = mCurrentPosition + offset;
                 if (imageNumber >= 0 && imageNumber < imageCount) {
                     if (!mCB.wantsFullImage(mCurrentPosition, offset)) {
                         continue;
                     }

                     IImage image = mImageList.getImageAt(imageNumber);
                     if (image == null) continue;
                     if (image instanceof VideoObject) continue;
                     if (mCancel) return;

                     int sizeToUse = mCB.fullImageSizeToUse(
                             mCurrentPosition, offset);
                     Bitmap b = image.fullSizeBitmap(sizeToUse, 3 * 1024 * 1024,
                             IImage.NO_ROTATE, IImage.USE_NATIVE);

                     if (b == null) continue;
                     if (mCancel) {
                         b.recycle();
                         return;
                     }

                     RotateBitmap rb = new RotateBitmap(b,
                             image.getDegreesRotated());

                     Runnable cb = callback(mCurrentPosition, offset,
                             false, rb, mCurrentSerial);
                     mHandler.postGetterCallback(cb);
                 }
             }

             mHandler.postGetterCallback(completedCallback(mCurrentSerial));
         }
     }

     public ImageGetter(ContentResolver cr) {
         mCr = cr;
         mGetterThread = new Thread(new ImageGetterRunnable());
         mGetterThread.setName("ImageGettter");
         mGetterThread.start();
     }

     // Cancels current loading (without waiting).
     public synchronized void cancelCurrent() {
         Util.Assert(mGetterThread != null);
         mCancel = true;
         BitmapManager.instance().cancelThreadDecoding(mGetterThread, mCr);
     }

     // Cancels current loading (with waiting).
     private synchronized void cancelCurrentAndWait() {
         cancelCurrent();
         while (mIdle != true) {
             try {
                 wait();
             } catch (InterruptedException ex) {
                 // ignore.
             }
         }
     }

     // Stops this image getter.
     public void stop() {
         synchronized (this) {
             cancelCurrentAndWait();
             mDone = true;
             notify();
         }
         try {
             mGetterThread.join();
         } catch (InterruptedException ex) {
             // Ignore the exception
         }
         mGetterThread = null;
     }

     public synchronized void setPosition(int position, ImageGetterCallback cb,
             IImageList imageList, GetterHandler handler) {
         // Cancel the previous request.
         cancelCurrentAndWait();

         // Set new data.
         mCurrentPosition = position;
         mCB = cb;
         mImageList = imageList;
         mHandler = handler;
         mCurrentSerial += 1;

         // Kick-start the current request.
         mCancel = false;
         BitmapManager.instance().allowThreadDecoding(mGetterThread);
         notify();
     }
 }

 class GetterHandler extends Handler {
     private static final int IMAGE_GETTER_CALLBACK = 1;

     @Override
     public void handleMessage(Message message) {
         switch(message.what) {
             case IMAGE_GETTER_CALLBACK:
                 ((Runnable) message.obj).run();
                 break;
         }
     }

     public void postGetterCallback(Runnable callback) {
        postDelayedGetterCallback(callback, 0);
     }

     public void postDelayedGetterCallback(Runnable callback, long delay) {
         if (callback == null) {
             throw new NullPointerException();
         }
         Message message = Message.obtain();
         message.what = IMAGE_GETTER_CALLBACK;
         message.obj = callback;
         sendMessageDelayed(message, delay);
     }

     public void removeAllGetterCallbacks() {
         removeMessages(IMAGE_GETTER_CALLBACK);
     }
 }
	/*
	* Copyright (C) 2009 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 com.android.camera.gallery.IImage;
	import com.android.camera.gallery.IImageList;
	import com.android.camera.gallery.VideoObject;

	import android.content.ContentResolver;
	import android.graphics.Bitmap;
	import android.os.Handler;
	import android.os.Message;
	import android.os.Process;
	import android.provider.MediaStore;

	/*
	* Here's the loading strategy. For any given image, load the thumbnail
	* into memory and post a callback to display the resulting bitmap.
	*
	* Then proceed to load the full image bitmap. Three things can
	* happen at this point:
	*
	* 1. the image fails to load because the UI thread decided
	* to move on to a different image. This "cancellation" happens
	* by virtue of the UI thread closing the stream containing the
	* image being decoded. BitmapFactory.decodeStream returns null
	* in this case.
	*
	* 2. the image loaded successfully. At that point we post
	* a callback to the UI thread to actually show the bitmap.
	*
	* 3. when the post runs it checks to see if the image that was
	* loaded is still the one we want. The UI may have moved on
	* to some other image and if so we just drop the newly loaded
	* bitmap on the floor.
	*/

	interface ImageGetterCallback {
	public void imageLoaded(int pos, int offset, RotateBitmap bitmap,
	boolean isThumb);
	public boolean wantsThumbnail(int pos, int offset);
	public boolean wantsFullImage(int pos, int offset);
	public int fullImageSizeToUse(int pos, int offset);
	public void completed();
	public int [] loadOrder();
	}

	class ImageGetter {

	@SuppressWarnings("unused")
	private static final String TAG = "ImageGetter";

	// The thread which does the work.
	private Thread mGetterThread;

	// The current request serial number.
	// This is increased by one each time a new job is assigned.
	// It is only written in the main thread.
	private int mCurrentSerial;

	// The base position that's being retrieved. The actual images retrieved
	// are this base plus each of the offets. -1 means there is no current
	// request needs to be finished.
	private int mCurrentPosition = -1;

	// The callback to invoke for each image.
	private ImageGetterCallback mCB;

	// The image list for the images.
	private IImageList mImageList;

	// The handler to do callback.
	private GetterHandler mHandler;

	// True if we want to cancel the current loading.
	private volatile boolean mCancel = true;

	// True if the getter thread is idle waiting.
	private boolean mIdle = false;

	// True when the getter thread should exit.
	private boolean mDone = false;

	private ContentResolver mCr;

	private class ImageGetterRunnable implements Runnable {

	private Runnable callback(final int position, final int offset,
	final boolean isThumb,
	final RotateBitmap bitmap,
	final int requestSerial) {
	return new Runnable() {
	public void run() {
	// check for inflight callbacks that aren't applicable
	// any longer before delivering them
	if (requestSerial == mCurrentSerial) {
	mCB.imageLoaded(position, offset, bitmap, isThumb);
	} else if (bitmap != null) {
	bitmap.recycle();
	}
	}
	};
	}

	private Runnable completedCallback(final int requestSerial) {
	return new Runnable() {
	public void run() {
	if (requestSerial == mCurrentSerial) {
	mCB.completed();
	}
	}
	};
	}

	public void run() {
	// Lower the priority of this thread to avoid competing with
	// the UI thread.
	Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);

	while (true) {
	synchronized (ImageGetter.this) {
	while (mCancel \|\| mDone \|\| mCurrentPosition == -1) {
	if (mDone) return;
	mIdle = true;
	ImageGetter.this.notify();
	try {
	ImageGetter.this.wait();
	} catch (InterruptedException ex) {
	// ignore
	}
	mIdle = false;
	}
	}

	executeRequest();

	synchronized (ImageGetter.this) {
	mCurrentPosition = -1;
	}
	}
	}
	private void executeRequest() {
	int imageCount = mImageList.getCount();

	int [] order = mCB.loadOrder();
	for (int i = 0; i < order.length; i++) {
	if (mCancel) return;
	int offset = order[i];
	int imageNumber = mCurrentPosition + offset;
	if (imageNumber >= 0 && imageNumber < imageCount) {
	if (!mCB.wantsThumbnail(mCurrentPosition, offset)) {
	continue;
	}

	IImage image = mImageList.getImageAt(imageNumber);
	if (image == null) continue;
	if (mCancel) return;

	Bitmap b = image.thumbBitmap(IImage.NO_ROTATE);
	if (b == null) continue;
	if (mCancel) {
	b.recycle();
	return;
	}

	Runnable cb = callback(mCurrentPosition, offset,
	true,
	new RotateBitmap(b, image.getDegreesRotated()),
	mCurrentSerial);
	mHandler.postGetterCallback(cb);
	}
	}

	for (int i = 0; i < order.length; i++) {
	if (mCancel) return;
	int offset = order[i];
	int imageNumber = mCurrentPosition + offset;
	if (imageNumber >= 0 && imageNumber < imageCount) {
	if (!mCB.wantsFullImage(mCurrentPosition, offset)) {
	continue;
	}

	IImage image = mImageList.getImageAt(imageNumber);
	if (image == null) continue;
	if (image instanceof VideoObject) continue;
	if (mCancel) return;

	int sizeToUse = mCB.fullImageSizeToUse(
	mCurrentPosition, offset);
	Bitmap b = image.fullSizeBitmap(sizeToUse, 3 * 1024 * 1024,
	IImage.NO_ROTATE, IImage.USE_NATIVE);

	if (b == null) continue;
	if (mCancel) {
	b.recycle();
	return;
	}

	RotateBitmap rb = new RotateBitmap(b,
	image.getDegreesRotated());

	Runnable cb = callback(mCurrentPosition, offset,
	false, rb, mCurrentSerial);
	mHandler.postGetterCallback(cb);
	}
	}

	mHandler.postGetterCallback(completedCallback(mCurrentSerial));
	}
	}

	public ImageGetter(ContentResolver cr) {
	mCr = cr;
	mGetterThread = new Thread(new ImageGetterRunnable());
	mGetterThread.setName("ImageGettter");
	mGetterThread.start();
	}

	// Cancels current loading (without waiting).
	public synchronized void cancelCurrent() {
	Util.Assert(mGetterThread != null);
	mCancel = true;
	BitmapManager.instance().cancelThreadDecoding(mGetterThread, mCr);
	}

	// Cancels current loading (with waiting).
	private synchronized void cancelCurrentAndWait() {
	cancelCurrent();
	while (mIdle != true) {
	try {
	wait();
	} catch (InterruptedException ex) {
	// ignore.
	}
	}
	}

	// Stops this image getter.
	public void stop() {
	synchronized (this) {
	cancelCurrentAndWait();
	mDone = true;
	notify();
	}
	try {
	mGetterThread.join();
	} catch (InterruptedException ex) {
	// Ignore the exception
	}
	mGetterThread = null;
	}

	public synchronized void setPosition(int position, ImageGetterCallback cb,
	IImageList imageList, GetterHandler handler) {
	// Cancel the previous request.
	cancelCurrentAndWait();

	// Set new data.
	mCurrentPosition = position;
	mCB = cb;
	mImageList = imageList;
	mHandler = handler;
	mCurrentSerial += 1;

	// Kick-start the current request.
	mCancel = false;
	BitmapManager.instance().allowThreadDecoding(mGetterThread);
	notify();
	}
	}

	class GetterHandler extends Handler {
	private static final int IMAGE_GETTER_CALLBACK = 1;

	@Override
	public void handleMessage(Message message) {
	switch(message.what) {
	case IMAGE_GETTER_CALLBACK:
	((Runnable) message.obj).run();
	break;
	}
	}

	public void postGetterCallback(Runnable callback) {
	postDelayedGetterCallback(callback, 0);
	}

	public void postDelayedGetterCallback(Runnable callback, long delay) {
	if (callback == null) {
	throw new NullPointerException();
	}
	Message message = Message.obtain();
	message.what = IMAGE_GETTER_CALLBACK;
	message.obj = callback;
	sendMessageDelayed(message, delay);
	}

	public void removeAllGetterCallbacks() {
	removeMessages(IMAGE_GETTER_CALLBACK);
	}
	}