AsyncTask에서 ImageView를로드하는 더 쉬운 방법은 무엇입니까?

Question

저는 AsyncTask에 있어야하는 LoadImageFromWeb을 사용하여 ImageView에서 작업하고 있습니다. 나는 단지 문자열을 사용하기 때문에 AsyncTask를하지만 다른를 사용하는 다른 프로그램을 만들었습니다

private void satellite() { 
     // TODO Auto-generated method stub 
    ImageView imgView =(ImageView)findViewById(R.id.satellite); 
    Drawable drawable = LoadImageFromWeb("http://www.pagasa.dost.gov.ph/wb/sat_images/satellite.gif"); 
    imgView.setImageDrawable(drawable); 

    } 

, 내 이제 이미지 뷰입니다 : AsyncTask를하지 않고 내 코드는이 아니라.

답변을 검색했지만 그 방법이 너무 혼란 스럽습니다.

public class MainActivity extends Activity { 

ImageView mImgView1; 
static Bitmap bm; 
ProgressDialog pd; 
String imageUrl = "https://www.morroccomethod.com/components/com_virtuemart/shop_image/category/resized/Trial_Sizes_4e4ac3b0d3491_175x175.jpg"; 
BitmapFactory.Options bmOptions; 

@Override 
public void onCreate(Bundle savedInstanceState) { 
    super.onCreate(savedInstanceState); 
    setContentView(R.layout.activity_main); 

    mImgView1 = (ImageView) findViewById(R.id.mImgView1); 
    pd = ProgressDialog.show(MainActivity.this, "Aguarde...", 
      "Carregando..."); 
    new ImageDownload().execute(""); 
} 

public class ImageDownload extends AsyncTask<String, Void, String> { 

    protected String doInBackground(String... params) { 
     // TODO Auto-generated method stub 
     bmOptions = new BitmapFactory.Options(); 
     bmOptions.inSampleSize = 1; 
     loadBitmap(imageUrl, bmOptions); 
     return imageUrl; 
    } 

    protected void onPostExecute(String imageUrl) { 
     pd.dismiss(); 
     if (!imageUrl.equals("")) { 
      mImgView1.setImageBitmap(bm); 
     } else { 
      Toast.makeText(MainActivity.this, 
        "Não foi possível obter resultados", Toast.LENGTH_LONG) 
        .show(); 
     } 
    } 

} 

public static Bitmap loadBitmap(String URL, BitmapFactory.Options options) { 
    InputStream in = null; 
    try { 
     in = OpenHttpConnection(URL); 
     bm = BitmapFactory.decodeStream(in, null, options); 
     in.close(); 
    } catch (IOException e1) { 
    } 
    return bm; 
} 

private static InputStream OpenHttpConnection(String strURL) 
     throws IOException { 
    InputStream inputStream = null; 
    URL url = new URL(strURL); 
    URLConnection conn = url.openConnection(); 

    try { 
     HttpURLConnection httpConn = (HttpURLConnection) conn; 
     httpConn.setRequestMethod("GET"); 
     httpConn.connect(); 

     if (httpConn.getResponseCode() == HttpURLConnection.HTTP_OK) { 
      inputStream = httpConn.getInputStream(); 
     } 
    } catch (Exception ex) { 
    } 
    return inputStream; 
} 

}

를하고 너무 많이 나는 이미지 뷰에 사용되는 내 접근 방식에서 (나를 위해) 복잡하다 : 그들은이 같은 것을 사용하고 있습니다.

제 질문은 : 두 번째 코드를 사용하는 것 외에 다른 어떤 방법보다 간단하고 쉬운 방법이 있습니까? 나는 그것을 작동 시키려고 노력했지만 그렇지 않습니다. 이미지에 관해서 AsyncTask를 수행하는 법을 모르겠습니다. 그리고 나는 좌절감을 느낀다. 사전에 도움 :) 여기

Answer 1

에 대한

감사는 LazyLaoding 및 기타 이미지 로딩 라이브러리로 이동되는 많은 답변입니다,하지만 당신은 훨씬 더 복잡한 방법을 갈 이유가 직접 간단한 AsyncTask를 함께 할 수있는 이행.

그냥 그냥 있는지 확인이 Bitmap params를 사용 doInBackground() 반환 Bitmap과 onPostExecute()에서 다음 AsyncTask's Constructor에 ImageView 참조를 전달 NULL하거나하지 경우 ImageVIew ..

예에 Null이 아님 다음 간단한 설정 비트 맵 :

protected Bitmap doInBackground(String... params)

및

여기

protected void onPostExecute(Bitmap bitmap)

Answer 2

유 UR 프로젝트에서 사용할 수있는 클래스 이미지 로더이고, u는 다만하여 ImageLoader,의 디스플레이 이미지 메소드를 호출 할 필요가있다.

  public class ImageLoader { 

MemoryCache memoryCache=new MemoryCache(); 
FileCache fileCache; 
private Map<ImageView, String> imageViews=Collections.synchronizedMap(new WeakHashMap<ImageView, String>()); 
ExecutorService executorService; 

public ImageLoader(Context context){ 
    fileCache=new FileCache(context); 
    executorService=Executors.newFixedThreadPool(5); 
} 

final int stub_id = R.drawable.no_image; 
public void DisplayImage(String url, ImageView imageView) 
{ 
    imageViews.put(imageView, url); 
    Bitmap bitmap=memoryCache.get(url); 
    if(bitmap!=null) 
     imageView.setImageBitmap(bitmap); 
    else 
    { 
     queuePhoto(url, imageView); 
     imageView.setImageResource(stub_id); 
    } 
} 

private void queuePhoto(String url, ImageView imageView) 
{ 
    PhotoToLoad p=new PhotoToLoad(url, imageView); 
    executorService.submit(new PhotosLoader(p)); 
} 

private 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(30000); 
     conn.setReadTimeout(30000); 
     conn.setInstanceFollowRedirects(true); 
     InputStream is=conn.getInputStream(); 
     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); 

     //Find the correct scale value. It should be the power of 2. 
     final int REQUIRED_SIZE=70; 
     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) {} 
    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; 
    } 
} 

class PhotosLoader implements Runnable { 
    PhotoToLoad photoToLoad; 
    PhotosLoader(PhotoToLoad photoToLoad){ 
     this.photoToLoad=photoToLoad; 
    } 


    public void run() { 
     if(imageViewReused(photoToLoad)) 
      return; 
     Bitmap bmp=getBitmap(photoToLoad.url); 
     memoryCache.put(photoToLoad.url, bmp); 
     if(imageViewReused(photoToLoad)) 
      return; 
     BitmapDisplayer bd=new BitmapDisplayer(bmp, photoToLoad); 
     Activity a=(Activity)photoToLoad.imageView.getContext(); 
     a.runOnUiThread(bd); 
    } 
} 

boolean imageViewReused(PhotoToLoad photoToLoad){ 
    String tag=imageViews.get(photoToLoad.imageView); 
    if(tag==null || !tag.equals(photoToLoad.url)) 
     return true; 
    return false; 
} 

//Used to display bitmap in the UI thread 
class BitmapDisplayer implements Runnable 
{ 
    Bitmap bitmap; 
    PhotoToLoad photoToLoad; 
    public BitmapDisplayer(Bitmap b, PhotoToLoad p){bitmap=b;photoToLoad=p;} 
    public void run() 
    { 
     if(imageViewReused(photoToLoad)) 
      return; 
     if(bitmap!=null) 
      photoToLoad.imageView.setImageBitmap(bitmap); 
     else 
      photoToLoad.imageView.setImageResource(stub_id); 
    } 
} 

public void clearCache() { 
    memoryCache.clear(); 
    fileCache.clear(); 
} 

}