Back to project page AndroidTrainingCode.
The source code is released under:
Apache License
If you think the Android project AndroidTrainingCode listed in this page is inappropriate, such as containing malicious code/tools or violating the copyright, please email info at java2s dot com, thanks.
/* * Copyright (C) 2012 The Android Open Source Project *//from www .ja v a 2 s .co m * 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(); } } }