samples/training/threadsample/src/com/example/android/threadsample/PhotoDecodeRunnable.java - platform/development - Git at Google

 /*
  * Copyright (C) 2012 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.example.android.threadsample;

 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
 import android.util.Log;

 /**
  * This runnable decodes a byte array containing an image.
  *
  * Objects of this class are instantiated and managed by instances of PhotoTask, which
  * implements the methods {@link TaskRunnableDecodeMethods}. PhotoTask objects call
  * {@link #PhotoDecodeRunnable(TaskRunnableDecodeMethods) PhotoDecodeRunnable()} with
  * themselves as the argument. In effect, an PhotoTask object and a
  * PhotoDecodeRunnable object communicate through the fields of the PhotoTask.
  *
  */
 class PhotoDecodeRunnable implements Runnable {

     // Limits the number of times the decoder tries to process an image
     private static final int NUMBER_OF_DECODE_TRIES = 2;

     // Tells the Runnable to pause for a certain number of milliseconds
     private static final long SLEEP_TIME_MILLISECONDS = 250;

     // Sets the log tag
     private static final String LOG_TAG = "PhotoDecodeRunnable";

     // Constants for indicating the state of the decode
     static final int DECODE_STATE_FAILED = -1;
     static final int DECODE_STATE_STARTED = 0;
     static final int DECODE_STATE_COMPLETED = 1;

     // Defines a field that contains the calling object of type PhotoTask.
     final TaskRunnableDecodeMethods mPhotoTask;

     /**
     *
     * An interface that defines methods that PhotoTask implements. An instance of
     * PhotoTask passes itself to an PhotoDecodeRunnable instance through the
     * PhotoDecodeRunnable constructor, after which the two instances can access each other's
     * variables.
     */
     interface TaskRunnableDecodeMethods {

         /**
          * Sets the Thread that this instance is running on
          * @param currentThread the current Thread
          */
         void setImageDecodeThread(Thread currentThread);

         /**
          * Returns the current contents of the download buffer
          * @return The byte array downloaded from the URL in the last read
          */
         byte[] getByteBuffer();

         /**
          * Sets the actions for each state of the PhotoTask instance.
          * @param state The state being handled.
          */
         void handleDecodeState(int state);

         /**
          * Returns the desired width of the image, based on the ImageView being created.
          * @return The target width
          */
         int getTargetWidth();

         /**
          * Returns the desired height of the image, based on the ImageView being created.
          * @return The target height.
          */
         int getTargetHeight();

         /**
          * Sets the Bitmap for the ImageView being displayed.
          * @param image
          */
         void setImage(Bitmap image);
     }

     /**
      * This constructor creates an instance of PhotoDownloadRunnable and stores in it a reference
      * to the PhotoTask instance that instantiated it.
      *
      * @param downloadTask The PhotoTask, which implements ImageDecoderRunnableCallback
      */
     PhotoDecodeRunnable(TaskRunnableDecodeMethods downloadTask) {
         mPhotoTask = downloadTask;
     }

     /*
      * Defines this object's task, which is a set of instructions designed to be run on a Thread.
      */
     @Override
     public void run() {

         /*
          * Stores the current Thread in the the PhotoTask instance, so that the instance
          * can interrupt the Thread.
          */
         mPhotoTask.setImageDecodeThread(Thread.currentThread());

         /*
          * Gets the image cache buffer object from the PhotoTask instance. This makes the
          * to both PhotoDownloadRunnable and PhotoTask.
          */
         byte[] imageBuffer = mPhotoTask.getByteBuffer();

         // Defines the Bitmap object that this thread will create
         Bitmap returnBitmap = null;

         /*
          * A try block that decodes a downloaded image.
          *
          */
         try {

             /*
              * Calls the PhotoTask implementation of {@link #handleDecodeState} to
              * set the state of the download
              */
             mPhotoTask.handleDecodeState(DECODE_STATE_STARTED);

             // Sets up options for creating a Bitmap object from the
             // downloaded image.
             BitmapFactory.Options bitmapOptions = new BitmapFactory.Options();

             /*
              * Sets the desired image height and width based on the
              * ImageView being created.
              */
             int targetWidth = mPhotoTask.getTargetWidth();
             int targetHeight = mPhotoTask.getTargetHeight();

             // Before continuing, checks to see that the Thread hasn't
             // been interrupted
             if (Thread.interrupted()) {

                 return;
             }

             /*
              * Even if the decoder doesn't set a Bitmap, this flag tells
              * the decoder to return the calculated bounds.
              */
             bitmapOptions.inJustDecodeBounds = true;

             /*
              * First pass of decoding to get scaling and sampling
              * parameters from the image
              */
             BitmapFactory
                     .decodeByteArray(imageBuffer, 0, imageBuffer.length, bitmapOptions);

             /*
              * Sets horizontal and vertical scaling factors so that the
              * image is expanded or compressed from its actual size to
              * the size of the target ImageView
              */
             int hScale = bitmapOptions.outHeight / targetHeight;
             int wScale = bitmapOptions.outWidth / targetWidth;

             /*
              * Sets the sample size to be larger of the horizontal or
              * vertical scale factor
              */
             //
             int sampleSize = Math.max(hScale, wScale);

             /*
              * If either of the scaling factors is > 1, the image's
              * actual dimension is larger that the available dimension.
              * This means that the BitmapFactory must compress the image
              * by the larger of the scaling factors. Setting
              * inSampleSize accomplishes this.
              */
             if (sampleSize > 1) {
                 bitmapOptions.inSampleSize = sampleSize;
             }

             if (Thread.interrupted()) {
                 return;
             }

             // Second pass of decoding. If no bitmap is created, nothing
             // is set in the object.
             bitmapOptions.inJustDecodeBounds = false;

             /*
              * This does the actual decoding of the buffer. If the
              * decode encounters an an out-of-memory error, it may throw
              * an Exception or an Error, both of which need to be
              * handled. Once the problem is handled, the decode is
              * re-tried.
              */
             for (int i = 0; i < NUMBER_OF_DECODE_TRIES; i++) {
                 try {
                     // Tries to decode the image buffer
                     returnBitmap = BitmapFactory.decodeByteArray(
                             imageBuffer,
                             0,
                             imageBuffer.length,
                             bitmapOptions
                             );
                     /*
                      * If the decode works, no Exception or Error has occurred.
                     break;

                     /*
                      * If the decode fails, this block tries to get more memory.
                      */
                 } catch (Throwable e) {

                     // Logs an error
                     Log.e(LOG_TAG, "Out of memory in decode stage. Throttling.");

                     /*
                      * Tells the system that garbage collection is
                      * necessary. Notice that collection may or may not
                      * occur.
                      */
                     java.lang.System.gc();

                     if (Thread.interrupted()) {
                         return;

                     }
                     /*
                      * Tries to pause the thread for 250 milliseconds,
                      * and catches an Exception if something tries to
                      * activate the thread before it wakes up.
                      */
                     try {
                         Thread.sleep(SLEEP_TIME_MILLISECONDS);
                     } catch (java.lang.InterruptedException interruptException) {
                         return;
                     }
                 }
             }

             // Catches exceptions if something tries to activate the
             // Thread incorrectly.
         } finally {
             // If the decode failed, there's no bitmap.
             if (null == returnBitmap) {

                 // Sends a failure status to the PhotoTask
                 mPhotoTask.handleDecodeState(DECODE_STATE_FAILED);

                 // Logs the error
                 Log.e(LOG_TAG, "Download failed in PhotoDecodeRunnable");

             } else {

                 // Sets the ImageView Bitmap
                 mPhotoTask.setImage(returnBitmap);

                 // Reports a status of "completed"
                 mPhotoTask.handleDecodeState(DECODE_STATE_COMPLETED);
             }

             // Sets the current Thread to null, releasing its storage
             mPhotoTask.setImageDecodeThread(null);

             // Clears the Thread's interrupt flag
             Thread.interrupted();

         }

     }
 }
	/*
	* Copyright (C) 2012 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.example.android.threadsample;

	import android.graphics.Bitmap;
	import android.graphics.BitmapFactory;
	import android.util.Log;

	/**
	* This runnable decodes a byte array containing an image.
	*
	* Objects of this class are instantiated and managed by instances of PhotoTask, which
	* implements the methods {@link TaskRunnableDecodeMethods}. PhotoTask objects call
	* {@link #PhotoDecodeRunnable(TaskRunnableDecodeMethods) PhotoDecodeRunnable()} with
	* themselves as the argument. In effect, an PhotoTask object and a
	* PhotoDecodeRunnable object communicate through the fields of the PhotoTask.
	*
	*/
	class PhotoDecodeRunnable implements Runnable {

	// Limits the number of times the decoder tries to process an image
	private static final int NUMBER_OF_DECODE_TRIES = 2;

	// Tells the Runnable to pause for a certain number of milliseconds
	private static final long SLEEP_TIME_MILLISECONDS = 250;

	// Sets the log tag
	private static final String LOG_TAG = "PhotoDecodeRunnable";

	// Constants for indicating the state of the decode
	static final int DECODE_STATE_FAILED = -1;
	static final int DECODE_STATE_STARTED = 0;
	static final int DECODE_STATE_COMPLETED = 1;

	// Defines a field that contains the calling object of type PhotoTask.
	final TaskRunnableDecodeMethods mPhotoTask;

	/**
	*
	* An interface that defines methods that PhotoTask implements. An instance of
	* PhotoTask passes itself to an PhotoDecodeRunnable instance through the
	* PhotoDecodeRunnable constructor, after which the two instances can access each other's
	* variables.
	*/
	interface TaskRunnableDecodeMethods {

	/**
	* Sets the Thread that this instance is running on
	* @param currentThread the current Thread
	*/
	void setImageDecodeThread(Thread currentThread);

	/**
	* Returns the current contents of the download buffer
	* @return The byte array downloaded from the URL in the last read
	*/
	byte[] getByteBuffer();

	/**
	* Sets the actions for each state of the PhotoTask instance.
	* @param state The state being handled.
	*/
	void handleDecodeState(int state);

	/**
	* Returns the desired width of the image, based on the ImageView being created.
	* @return The target width
	*/
	int getTargetWidth();

	/**
	* Returns the desired height of the image, based on the ImageView being created.
	* @return The target height.
	*/
	int getTargetHeight();

	/**
	* Sets the Bitmap for the ImageView being displayed.
	* @param image
	*/
	void setImage(Bitmap image);
	}

	/**
	* This constructor creates an instance of PhotoDownloadRunnable and stores in it a reference
	* to the PhotoTask instance that instantiated it.
	*
	* @param downloadTask The PhotoTask, which implements ImageDecoderRunnableCallback
	*/
	PhotoDecodeRunnable(TaskRunnableDecodeMethods downloadTask) {
	mPhotoTask = downloadTask;
	}

	/*
	* Defines this object's task, which is a set of instructions designed to be run on a Thread.
	*/
	@Override
	public void run() {

	/*
	* Stores the current Thread in the the PhotoTask instance, so that the instance
	* can interrupt the Thread.
	*/
	mPhotoTask.setImageDecodeThread(Thread.currentThread());

	/*
	* Gets the image cache buffer object from the PhotoTask instance. This makes the
	* to both PhotoDownloadRunnable and PhotoTask.
	*/
	byte[] imageBuffer = mPhotoTask.getByteBuffer();

	// Defines the Bitmap object that this thread will create
	Bitmap returnBitmap = null;

	/*
	* A try block that decodes a downloaded image.
	*
	*/
	try {

	/*
	* Calls the PhotoTask implementation of {@link #handleDecodeState} to
	* set the state of the download
	*/
	mPhotoTask.handleDecodeState(DECODE_STATE_STARTED);

	// Sets up options for creating a Bitmap object from the
	// downloaded image.
	BitmapFactory.Options bitmapOptions = new BitmapFactory.Options();

	/*
	* Sets the desired image height and width based on the
	* ImageView being created.
	*/
	int targetWidth = mPhotoTask.getTargetWidth();
	int targetHeight = mPhotoTask.getTargetHeight();

	// Before continuing, checks to see that the Thread hasn't
	// been interrupted
	if (Thread.interrupted()) {

	return;
	}

	/*
	* Even if the decoder doesn't set a Bitmap, this flag tells
	* the decoder to return the calculated bounds.
	*/
	bitmapOptions.inJustDecodeBounds = true;

	/*
	* First pass of decoding to get scaling and sampling
	* parameters from the image
	*/
	BitmapFactory
	.decodeByteArray(imageBuffer, 0, imageBuffer.length, bitmapOptions);

	/*
	* Sets horizontal and vertical scaling factors so that the
	* image is expanded or compressed from its actual size to
	* the size of the target ImageView
	*/
	int hScale = bitmapOptions.outHeight / targetHeight;
	int wScale = bitmapOptions.outWidth / targetWidth;

	/*
	* Sets the sample size to be larger of the horizontal or
	* vertical scale factor
	*/
	//
	int sampleSize = Math.max(hScale, wScale);

	/*
	* If either of the scaling factors is > 1, the image's
	* actual dimension is larger that the available dimension.
	* This means that the BitmapFactory must compress the image
	* by the larger of the scaling factors. Setting
	* inSampleSize accomplishes this.
	*/
	if (sampleSize > 1) {
	bitmapOptions.inSampleSize = sampleSize;
	}

	if (Thread.interrupted()) {
	return;
	}

	// Second pass of decoding. If no bitmap is created, nothing
	// is set in the object.
	bitmapOptions.inJustDecodeBounds = false;

	/*
	* This does the actual decoding of the buffer. If the
	* decode encounters an an out-of-memory error, it may throw
	* an Exception or an Error, both of which need to be
	* handled. Once the problem is handled, the decode is
	* re-tried.
	*/
	for (int i = 0; i < NUMBER_OF_DECODE_TRIES; i++) {
	try {
	// Tries to decode the image buffer
	returnBitmap = BitmapFactory.decodeByteArray(
	imageBuffer,
	0,
	imageBuffer.length,
	bitmapOptions
	);
	/*
	* If the decode works, no Exception or Error has occurred.
	break;

	/*
	* If the decode fails, this block tries to get more memory.
	*/
	} catch (Throwable e) {

	// Logs an error
	Log.e(LOG_TAG, "Out of memory in decode stage. Throttling.");

	/*
	* Tells the system that garbage collection is
	* necessary. Notice that collection may or may not
	* occur.
	*/
	java.lang.System.gc();

	if (Thread.interrupted()) {
	return;

	}
	/*
	* Tries to pause the thread for 250 milliseconds,
	* and catches an Exception if something tries to
	* activate the thread before it wakes up.
	*/
	try {
	Thread.sleep(SLEEP_TIME_MILLISECONDS);
	} catch (java.lang.InterruptedException interruptException) {
	return;
	}
	}
	}

	// Catches exceptions if something tries to activate the
	// Thread incorrectly.
	} finally {
	// If the decode failed, there's no bitmap.
	if (null == returnBitmap) {

	// Sends a failure status to the PhotoTask
	mPhotoTask.handleDecodeState(DECODE_STATE_FAILED);

	// Logs the error
	Log.e(LOG_TAG, "Download failed in PhotoDecodeRunnable");

	} else {

	// Sets the ImageView Bitmap
	mPhotoTask.setImage(returnBitmap);

	// Reports a status of "completed"
	mPhotoTask.handleDecodeState(DECODE_STATE_COMPLETED);
	}

	// Sets the current Thread to null, releasing its storage
	mPhotoTask.setImageDecodeThread(null);

	// Clears the Thread's interrupt flag
	Thread.interrupted();

	}

	}
	}