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) ${year} The Android Open Source Project *//from w w w. j a v a 2 s .c om * 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 com.example.android.threadsample.PhotoDecodeRunnable.TaskRunnableDecodeMethods; import java.io.EOFException; import java.io.IOException; import java.io.InputStream; import java.net.HttpURLConnection; import java.net.URL; /** * This task downloads bytes from a resource addressed by a URL. When the task * has finished, it calls handleState to report its results. * * Objects of this class are instantiated and managed by instances of PhotoTask, which * implements the methods of {@link TaskRunnableDecodeMethods}. PhotoTask objects call * {@link #PhotoDownloadRunnable(TaskRunnableDownloadMethods) PhotoDownloadRunnable()} with * themselves as the argument. In effect, an PhotoTask object and a * PhotoDownloadRunnable object communicate through the fields of the PhotoTask. */ class PhotoDownloadRunnable implements Runnable { // Sets the size for each read action (bytes) private static final int READ_SIZE = 1024 * 2; // Sets a tag for this class @SuppressWarnings("unused") private static final String LOG_TAG = "PhotoDownloadRunnable"; // Constants for indicating the state of the download static final int HTTP_STATE_FAILED = -1; static final int HTTP_STATE_STARTED = 0; static final int HTTP_STATE_COMPLETED = 1; // Defines a field that contains the calling object of type PhotoTask. final TaskRunnableDownloadMethods mPhotoTask; /** * * An interface that defines methods that PhotoTask implements. An instance of * PhotoTask passes itself to an PhotoDownloadRunnable instance through the * PhotoDownloadRunnable constructor, after which the two instances can access each other's * variables. */ interface TaskRunnableDownloadMethods { /** * Sets the Thread that this instance is running on * @param currentThread the current Thread */ void setDownloadThread(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 current contents of the download buffer * @param buffer The bytes that were just read */ void setByteBuffer(byte[] buffer); /** * Defines the actions for each state of the PhotoTask instance. * @param state The current state of the task */ void handleDownloadState(int state); /** * Gets the URL for the image being downloaded * @return The image URL */ URL getImageURL(); } /** * This constructor creates an instance of PhotoDownloadRunnable and stores in it a reference * to the PhotoTask instance that instantiated it. * * @param photoTask The PhotoTask, which implements TaskRunnableDecodeMethods */ PhotoDownloadRunnable(TaskRunnableDownloadMethods photoTask) { mPhotoTask = photoTask; } /* * Defines this object's task, which is a set of instructions designed to be run on a Thread. */ @SuppressWarnings("resource") @Override public void run() { /* * Stores the current Thread in the the PhotoTask instance, so that the instance * can interrupt the Thread. */ mPhotoTask.setDownloadThread(Thread.currentThread()); // Moves the current Thread into the background android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_BACKGROUND); /* * Gets the image cache buffer object from the PhotoTask instance. This makes the * to both PhotoDownloadRunnable and PhotoTask. */ byte[] byteBuffer = mPhotoTask.getByteBuffer(); /* * A try block that downloads a Picasa image from a URL. The URL value is in the field * PhotoTask.mImageURL */ // Tries to download the picture from Picasa try { // Before continuing, checks to see that the Thread hasn't been // interrupted if (Thread.interrupted()) { throw new InterruptedException(); } // If there's no cache buffer for this image if (null == byteBuffer) { /* * Calls the PhotoTask implementation of {@link #handleDownloadState} to * set the state of the download */ mPhotoTask.handleDownloadState(HTTP_STATE_STARTED); // Defines a handle for the byte download stream InputStream byteStream = null; // Downloads the image and catches IO errors try { // Opens an HTTP connection to the image's URL HttpURLConnection httpConn = (HttpURLConnection) mPhotoTask.getImageURL().openConnection(); // Sets the user agent to report to the server httpConn.setRequestProperty("User-Agent", Constants.USER_AGENT); // Before continuing, checks to see that the Thread // hasn't been interrupted if (Thread.interrupted()) { throw new InterruptedException(); } // Gets the input stream containing the image byteStream = httpConn.getInputStream(); if (Thread.interrupted()) { throw new InterruptedException(); } /* * Gets the size of the file being downloaded. This * may or may not be returned. */ int contentSize = httpConn.getContentLength(); /* * If the size of the image isn't available */ if (-1 == contentSize) { // Allocates a temporary buffer byte[] tempBuffer = new byte[READ_SIZE]; // Records the initial amount of available space int bufferLeft = tempBuffer.length; /* * Defines the initial offset of the next available * byte in the buffer, and the initial result of * reading the binary */ int bufferOffset = 0; int readResult = 0; /* * The "outer" loop continues until all the bytes * have been downloaded. The inner loop continues * until the temporary buffer is full, and then * allocates more buffer space. */ outer: do { while (bufferLeft > 0) { /* * Reads from the URL location into * the temporary buffer, starting at the * next available free byte and reading as * many bytes as are available in the * buffer. */ readResult = byteStream.read(tempBuffer, bufferOffset, bufferLeft); /* * InputStream.read() returns zero when the * file has been completely read. */ if (readResult < 0) { // The read is finished, so this breaks // the to "outer" loop break outer; } /* * The read isn't finished. This sets the * next available open position in the * buffer (the buffer index is 0-based). */ bufferOffset += readResult; // Subtracts the number of bytes read from // the amount of buffer left bufferLeft -= readResult; if (Thread.interrupted()) { throw new InterruptedException(); } } /* * The temporary buffer is full, so the * following code creates a new buffer that can * contain the existing contents plus the next * read cycle. */ // Resets the amount of buffer left to be the // max buffer size bufferLeft = READ_SIZE; /* * Sets a new size that can contain the existing * buffer's contents plus space for the next * read cycle. */ int newSize = tempBuffer.length + READ_SIZE; /* * Creates a new temporary buffer, moves the * contents of the old temporary buffer into it, * and then points the temporary buffer variable * to the new buffer. */ byte[] expandedBuffer = new byte[newSize]; System.arraycopy(tempBuffer, 0, expandedBuffer, 0, tempBuffer.length); tempBuffer = expandedBuffer; } while (true); /* * When the entire image has been read, this creates * a permanent byte buffer with the same size as * the number of used bytes in the temporary buffer * (equal to the next open byte, because tempBuffer * is 0=based). */ byteBuffer = new byte[bufferOffset]; // Copies the temporary buffer to the image buffer System.arraycopy(tempBuffer, 0, byteBuffer, 0, bufferOffset); /* * The download size is available, so this creates a * permanent buffer of that length. */ } else { byteBuffer = new byte[contentSize]; // How much of the buffer still remains empty int remainingLength = contentSize; // The next open space in the buffer int bufferOffset = 0; /* * Reads into the buffer until the number of bytes * equal to the length of the buffer (the size of * the image) have been read. */ while (remainingLength > 0) { int readResult = byteStream.read( byteBuffer, bufferOffset, remainingLength); /* * EOF should not occur, because the loop should * read the exact # of bytes in the image */ if (readResult < 0) { // Throws an EOF Exception throw new EOFException(); } // Moves the buffer offset to the next open byte bufferOffset += readResult; // Subtracts the # of bytes read from the // remaining length remainingLength -= readResult; if (Thread.interrupted()) { throw new InterruptedException(); } } } if (Thread.interrupted()) { throw new InterruptedException(); } // If an IO error occurs, returns immediately } catch (IOException e) { e.printStackTrace(); return; /* * If the input stream is still open, close it */ } finally { if (null != byteStream) { try { byteStream.close(); } catch (Exception e) { } } } } /* * Stores the downloaded bytes in the byte buffer in the PhotoTask instance. */ mPhotoTask.setByteBuffer(byteBuffer); /* * Sets the status message in the PhotoTask instance. This sets the * ImageView background to indicate that the image is being * decoded. */ mPhotoTask.handleDownloadState(HTTP_STATE_COMPLETED); // Catches exceptions thrown in response to a queued interrupt } catch (InterruptedException e1) { // Does nothing // In all cases, handle the results } finally { // If the byteBuffer is null, reports that the download failed. if (null == byteBuffer) { mPhotoTask.handleDownloadState(HTTP_STATE_FAILED); } /* * The implementation of setHTTPDownloadThread() in PhotoTask calls * PhotoTask.setCurrentThread(), which then locks on the static ThreadPool * object and returns the current thread. Locking keeps all references to Thread * objects the same until the reference to the current Thread is deleted. */ // Sets the reference to the current Thread to null, releasing its storage mPhotoTask.setDownloadThread(null); // Clears the Thread's interrupt flag Thread.interrupted(); } } }