samples/training/threadsample/src/com/example/android/threadsample/PhotoView.java - platform/development.git - 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.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);
         }
     }
 }
	/*
	* 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.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);
	}
	}
	}