2012-11-10 29 views
1

我有一個ImageDownloader該類的類我正在通過傳遞一些URL從ArrayList下載圖像。所以如何在按下下載動作按鈕後給出進度條,以及如何知道在完成下載時我們可以關閉對話框。在這個下面是ImageDownloader類。如何在從Url下載圖像時給進度條

import java.io.File; 
import java.io.FileInputStream; 
import java.io.FileNotFoundException; 
import java.io.FileOutputStream; 
import java.io.InputStream; 
import java.io.OutputStream; 
import java.net.HttpURLConnection; 
import java.net.URL; 
import java.util.Collections; 
import java.util.HashMap; 
import java.util.Map; 
import java.util.Stack; 
import java.util.WeakHashMap; 

import android.app.Activity; 
import android.content.Context; 
import android.graphics.Bitmap; 
import android.graphics.BitmapFactory; 
import android.graphics.drawable.BitmapDrawable; 
import android.util.Log; 
import android.widget.ImageView; 




public class ImageLoader { 

    MemoryCache memoryCache=new MemoryCache(); 
    FileCache fileCache; 
    static Bitmap bitmap; 
    private Map<ImageView, String> imageViews=Collections.synchronizedMap(new WeakHashMap<ImageView, String>()); 
    String detail; 

    public ImageLoader(Context context){ 
     //Make the background thead low priority. This way it will not affect the UI performance 
     photoLoaderThread.setPriority(Thread.NORM_PRIORITY-1); 

     fileCache=new FileCache(context); 


    } 

// final int stub_id=R.drawable.stub; 
    public void DisplayImage(String url,ImageView imageView,String detail) 
    { 

     imageViews.put(imageView, url); 
     this.detail=detail; 
     Bitmap bitmap=memoryCache.get(url); 
     if(bitmap!=null){ 
     int reqHgt=(bitmap.getHeight()*Home.d.getWidth())/bitmap.getWidth(); 
     bitmap=Bitmap.createScaledBitmap(bitmap,Home.d.getWidth(),reqHgt,true); 
     imageView.setImageBitmap(bitmap); 

     } 
     else 
     { 

      queuePhoto(url, imageView); 

     }  
    } 

    private void queuePhoto(String url, ImageView imageView) 
    { 
     //This ImageView may be used for other images before. So there may be some old tasks in the queue. We need to discard them. 
     photosQueue.Clean(imageView); 
     PhotoToLoad p=new PhotoToLoad(url, imageView); 
     synchronized(photosQueue.photosToLoad){ 
      photosQueue.photosToLoad.push(p); 
      photosQueue.photosToLoad.notifyAll(); 

     } 

     //start thread if it's not started yet 
     if(photoLoaderThread.getState()==Thread.State.NEW) 
      photoLoaderThread.start(); 
    } 

    Bitmap getBitmap(String url) 
    { 
     File f=fileCache.getFile(url); 

     //from SD cache 
     Bitmap b = decodeFile(f); 
     if(b!=null) 
      return b; 

     //from web 
     try { 
      Bitmap bitmap=null; 
      URL imageUrl = new URL(url); 
      HttpURLConnection conn = (HttpURLConnection)imageUrl.openConnection(); 
      conn.setConnectTimeout(15000); 
      conn.setReadTimeout(15000); 
      InputStream is=conn.getInputStream(); 
      Log.w("INput",is.toString()); 
      OutputStream os = new FileOutputStream(f); 
      Utils.CopyStream(is, os); 

      os.close(); 
      bitmap = decodeFile(f); 
      return bitmap; 
     } catch (Exception ex){ 
      ex.printStackTrace(); 
      return null; 
     } 
    } 

    //decodes image and scales it to reduce memory consumption 
    private Bitmap decodeFile(File f){ 
     try { 
      //decode image size 
      BitmapFactory.Options o = new BitmapFactory.Options(); 
      o.inJustDecodeBounds = true; 
      BitmapFactory.decodeStream(new FileInputStream(f),null,o); 
      Log.w("called2","called2"); 
      //Find the correct scale value. It should be the power of 2. 
      final int REQUIRED_SIZE=550; 
      int width_tmp=o.outWidth, height_tmp=o.outHeight; 
      int scale=1; 
      while(true){ 
       if(width_tmp/2<REQUIRED_SIZE || height_tmp/2<REQUIRED_SIZE) 
        break; 
       width_tmp/=2; 
       height_tmp/=2; 
       scale*=2; 
      } 

      //decode with inSampleSize 
      BitmapFactory.Options o2 = new BitmapFactory.Options(); 
      o2.inSampleSize=scale; 
      return BitmapFactory.decodeStream(new FileInputStream(f), null, o2); 
     } catch (FileNotFoundException e) { 
      e.printStackTrace(); 
     } 
     return null; 
    } 

    //Task for the queue 
    private class PhotoToLoad 
    { 
     public String url; 
     public ImageView imageView; 
     public PhotoToLoad(String u, ImageView i){ 
      url=u; 
      imageView=i; 
     } 
    } 

    PhotosQueue photosQueue=new PhotosQueue(); 

    public void stopThread() 
    { 
     photoLoaderThread.interrupt(); 
    } 

    //stores list of photos to download 
    class PhotosQueue 
    { 
     private Stack<PhotoToLoad> photosToLoad=new Stack<PhotoToLoad>(); 

     //removes all instances of this ImageView 
     public void Clean(ImageView image) 
     { 
      for(int j=0 ;j<photosToLoad.size();){ 
       if(photosToLoad.get(j).imageView==image) 
        photosToLoad.remove(j); 
       else 
        ++j; 
      } 
     } 
    } 

    class PhotosLoader extends Thread { 
     public void run() { 
      try { 
       while(true) 
       { 
        //thread waits until there are any images to load in the queue 
        if(photosQueue.photosToLoad.size()==0) 
         synchronized(photosQueue.photosToLoad){ 
          photosQueue.photosToLoad.wait(); 
         } 
        if(photosQueue.photosToLoad.size()!=0) 
        { 
         PhotoToLoad photoToLoad; 
         synchronized(photosQueue.photosToLoad){ 
          photoToLoad=photosQueue.photosToLoad.pop(); 
         } 
         Bitmap bmp=getBitmap(photoToLoad.url); 
         if(detail!=null){ 
         int reqHgt=(bmp.getHeight()*Home.d.getWidth())/bmp.getWidth(); 

         bmp=Bitmap.createScaledBitmap(bmp,Home.d.getWidth(),reqHgt,true); 
         } 

         memoryCache.put(photoToLoad.url, bmp); 
         String tag=imageViews.get(photoToLoad.imageView); 
         if(tag!=null && tag.equals(photoToLoad.url)){ 
          Log.e("koti-----","-----koti"); 
          int reqHgt=(bmp.getHeight()*Home.d.getWidth())/bmp.getWidth(); 
          bmp=Bitmap.createScaledBitmap(bmp,Home.d.getWidth(),reqHgt,true); 
          BitmapDisplayer bd=new BitmapDisplayer(bmp, photoToLoad.imageView); 
          Activity a=(Activity)photoToLoad.imageView.getContext(); 
          a.runOnUiThread(bd); 
         } 
        } 
        if(Thread.interrupted()) 
         break; 
       } 
      } catch (InterruptedException e) { 
       //allow thread to exit 
      } 
     } 
    } 

    PhotosLoader photoLoaderThread=new PhotosLoader(); 

    //Used to display bitmap in the UI thread 
    class BitmapDisplayer implements Runnable 
    { 
     Bitmap bitmap; 
     ImageView imageView; 
     public BitmapDisplayer(Bitmap b, ImageView i){bitmap=b;imageView=i;} 
     public void run() 
     { 
      if(bitmap!=null) 
      // reqHgt=(bmp.getHeight()*Welcome.d.getWidth())/bmp.getWidth(); 
       Log.w("called4","called4"); 

       imageView.setBackgroundDrawable(new BitmapDrawable(bitmap)); 


     } 
    } 
public Bitmap getLatestBitmap() 
    { 
    return bitmap; 
    } 
    public void clearCache() { 
     memoryCache.clear(); 
     fileCache.clear(); 
    } 

} 

回答

0

你真的應該使用AsynchTask的是,對於該文件的例子就是你在尋找什麼該做,發現here

3
call this class for file Download := 
new DownloadFileFromURL().execute(file_url); 


/** 
* Background Async Task to download file 
* */ 
class DownloadFileFromURL extends AsyncTask<String, String, String> { 

    /** 
    * Before starting background thread 
    * Show Progress Bar Dialog 
    * */ 
    @Override 
    protected void onPreExecute() { 
     super.onPreExecute(); 
     showDialog(progress_bar_type); 
    } 

    /** 
    * Downloading file in background thread 
    * */ 
    @Override 
    protected String doInBackground(String... f_url) { 
     int count; 
     try { 
      URL url = new URL(f_url[0]); 
      URLConnection conection = url.openConnection(); 
      conection.connect(); 
      // getting file length 
      int lenghtOfFile = conection.getContentLength(); 

      // input stream to read file - with 8k buffer 
      InputStream input = new BufferedInputStream(url.openStream(), 8192); 

      // Output stream to write file 
      OutputStream output = new FileOutputStream("/sdcard/downloadedfile.jpg"); 

      byte data[] = new byte[1024]; 

      long total = 0; 

      while ((count = input.read(data)) != -1) { 
       total += count; 
       // publishing the progress.... 
       // After this onProgressUpdate will be called 
       publishProgress(""+(int)((total*100)/lenghtOfFile)); 

       // writing data to file 
       output.write(data, 0, count); 
      } 

      // flushing output 
      output.flush(); 

      // closing streams 
      output.close(); 
      input.close(); 

     } catch (Exception e) { 
      Log.e("Error: ", e.getMessage()); 
     } 

     return null; 
    } 

    /** 
    * Updating progress bar 
    * */ 
    protected void onProgressUpdate(String... progress) { 
     // setting progress percentage 
     pDialog.setProgress(Integer.parseInt(progress[0])); 
    } 

    /** 
    * After completing background task 
    * Dismiss the progress dialog 
    * **/ 
    @Override 
    protected void onPostExecute(String file_url) { 
     // dismiss the dialog after the file was downloaded 
     dismissDialog(progress_bar_type); 

     // Displaying downloaded image into image view 
     // Reading image path from sdcard 
     String imagePath = Environment.getExternalStorageDirectory().toString() + "/downloadedfile.jpg"; 
     // setting downloaded into image view 
     my_image.setImageDrawable(Drawable.createFromPath(imagePath)); 
    } 

}