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 *// w w w . ja va 2 s . c o 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.content.Context; import android.content.res.TypedArray; import android.graphics.Bitmap; import android.graphics.Canvas; import android.graphics.drawable.Drawable; import android.net.Uri; import android.util.AttributeSet; import android.view.View; import android.widget.ImageView; import java.lang.ref.WeakReference; import java.net.URL; /** * This class extends the standard Android ImageView View class with some features * that are useful for downloading, decoding, and displaying Picasa images. * */ public class PhotoView extends ImageView { // Indicates if caching should be used private boolean mCacheFlag; // Status flag that indicates if onDraw has completed private boolean mIsDrawn; /* * Creates a weak reference to the ImageView in this object. The weak * reference prevents memory leaks and crashes, because it automatically tracks the "state" of * the variable it backs. If the reference becomes invalid, the weak reference is garbage- * collected. * This technique is important for referring to objects that are part of a component lifecycle. * Using a hard reference may cause memory leaks as the value continues to change; even worse, * it can cause crashes if the underlying component is destroyed. Using a weak reference to * a View ensures that the reference is more transitory in nature. */ private WeakReference<View> mThisView; // Contains the ID of the internal View private int mHideShowResId = -1; // The URL that points to the source of the image for this ImageView private URL mImageURL; // The Thread that will be used to download the image for this ImageView private PhotoTask mDownloadThread; /** * Creates an ImageDownloadView with no settings * @param context A context for the View */ public PhotoView(Context context) { super(context); } /** * Creates an ImageDownloadView and gets attribute values * @param context A Context to use with the View * @param attributeSet The entire set of attributes for the View */ public PhotoView(Context context, AttributeSet attributeSet) { super(context, attributeSet); // Gets attributes associated with the attribute set getAttributes(attributeSet); } /** * Creates an ImageDownloadView, gets attribute values, and applies a default style * @param context A context for the View * @param attributeSet The entire set of attributes for the View * @param defaultStyle The default style to use with the View */ public PhotoView(Context context, AttributeSet attributeSet, int defaultStyle) { super(context, attributeSet, defaultStyle); // Gets attributes associated with the attribute set getAttributes(attributeSet); } /** * Gets the resource ID for the hideShowSibling resource * @param attributeSet The entire set of attributes for the View */ private void getAttributes(AttributeSet attributeSet) { // Gets an array of attributes for the View TypedArray attributes = getContext().obtainStyledAttributes(attributeSet, R.styleable.ImageDownloaderView); // Gets the resource Id of the View to hide or show mHideShowResId = attributes.getResourceId(R.styleable.ImageDownloaderView_hideShowSibling, -1); // Returns the array for re-use attributes.recycle(); } /** * Sets the visibility of the PhotoView * @param visState The visibility state (see View.setVisibility) */ private void showView(int visState) { // If the View contains something if (mThisView != null) { // Gets a local hard reference to the View View localView = mThisView.get(); // If the weak reference actually contains something, set the visibility if (localView != null) localView.setVisibility(visState); } } /** * Sets the image in this ImageView to null, and makes the View visible */ public void clearImage() { setImageDrawable(null); showView(View.VISIBLE); } /** * Returns the URL of the picture associated with this ImageView * @return a URL */ final URL getLocation() { return mImageURL; } /* * This callback is invoked when the system attaches the ImageView to a Window. The callback * is invoked before onDraw(), but may be invoked after onMeasure() */ @Override protected void onAttachedToWindow() { // Always call the supermethod first super.onAttachedToWindow(); // If the sibling View is set and the parent of the ImageView is itself a View if ((this.mHideShowResId != -1) && ((getParent() instanceof View))) { // Gets a handle to the sibling View View localView = ((View) getParent()).findViewById(this.mHideShowResId); // If the sibling View contains something, make it the weak reference for this View if (localView != null) { this.mThisView = new WeakReference<View>(localView); } } } /* * This callback is invoked when the ImageView is removed from a Window. It "unsets" variables * to prevent memory leaks. */ @Override protected void onDetachedFromWindow() { // Clears out the image drawable, turns off the cache, disconnects the view from a URL setImageURL(null, false, null); // Gets the current Drawable, or null if no Drawable is attached Drawable localDrawable = getDrawable(); // if the Drawable is null, unbind it from this VIew if (localDrawable != null) localDrawable.setCallback(null); // If this View still exists, clears the weak reference, then sets the reference to null if (mThisView != null) { mThisView.clear(); mThisView = null; } // Sets the downloader thread to null this.mDownloadThread = null; // Always call the super method last super.onDetachedFromWindow(); } /* * This callback is invoked when the system tells the View to draw itself. If the View isn't * already drawn, and its URL isn't null, it invokes a Thread to download the image. Otherwise, * it simply passes the existing Canvas to the super method */ @Override protected void onDraw(Canvas canvas) { // If the image isn't already drawn, and the URL is set if ((!mIsDrawn) && (mImageURL != null)) { // Starts downloading this View, using the current cache setting mDownloadThread = PhotoManager.startDownload(this, mCacheFlag); // After successfully downloading the image, this marks that it's available. mIsDrawn = true; } // Always call the super method last super.onDraw(canvas); } /** * Sets the current View weak reference to be the incoming View. See the definition of * mThisView * @param view the View to use as the new WeakReference */ public void setHideView(View view) { this.mThisView = new WeakReference<View>(view); } @Override public void setImageBitmap(Bitmap paramBitmap) { super.setImageBitmap(paramBitmap); } @Override public void setImageDrawable(Drawable drawable) { // The visibility of the View int viewState; /* * Sets the View state to visible if the method is called with a null argument (the * image is being cleared). Otherwise, sets the View state to invisible before refreshing * it. */ if (drawable == null) { viewState = View.VISIBLE; } else { viewState = View.INVISIBLE; } // Either hides or shows the View, depending on the view state showView(viewState); // Invokes the supermethod with the provided drawable super.setImageDrawable(drawable); } /* * Displays a drawable in the View */ @Override public void setImageResource(int resId) { super.setImageResource(resId); } /* * Sets the URI for the Image */ @Override public void setImageURI(Uri uri) { super.setImageURI(uri); } /** * Attempts to set the picture URL for this ImageView and then download the picture. * <p> * If the picture URL for this view is already set, and the input URL is not the same as the * stored URL, then the picture has moved and any existing downloads are stopped. * <p> * If the input URL is the same as the stored URL, then nothing needs to be done. * <p> * If the stored URL is null, then this method starts a download and decode of the picture * @param pictureURL An incoming URL for a Picasa picture * @param cacheFlag Whether to use caching when doing downloading and decoding * @param imageDrawable The Drawable to use for this ImageView */ public void setImageURL(URL pictureURL, boolean cacheFlag, Drawable imageDrawable) { // If the picture URL for this ImageView is already set if (mImageURL != null) { // If the stored URL doesn't match the incoming URL, then the picture has changed. if (!mImageURL.equals(pictureURL)) { // Stops any ongoing downloads for this ImageView PhotoManager.removeDownload(mDownloadThread, mImageURL); } else { // The stored URL matches the incoming URL. Returns without doing any work. return; } } // Sets the Drawable for this ImageView setImageDrawable(imageDrawable); // Stores the picture URL for this ImageView mImageURL = pictureURL; // If the draw operation for this ImageVIew has completed, and the picture URL isn't empty if ((mIsDrawn) && (pictureURL != null)) { // Sets the cache flag mCacheFlag = cacheFlag; /* * Starts a download of the picture file. Notice that if caching is on, the picture * file's contents may be taken from the cache. */ mDownloadThread = PhotoManager.startDownload(this, cacheFlag); } } /** * Sets the Drawable for this ImageView * @param drawable A Drawable to use for the ImageView */ public void setStatusDrawable(Drawable drawable) { // If the View is empty, sets a Drawable as its content if (mThisView == null) { setImageDrawable(drawable); } } /** * Sets the content of this ImageView to be a Drawable resource * @param resId */ public void setStatusResource(int resId) { // If the View is empty, provides it with a Drawable resource as its content if (mThisView == null) { setImageResource(resId); } } }