inputstream.read n'a pas de réponse lors du téléchargement de grande image (taille> 300K)

Question

Salut les gars. J'ai un problème lors du téléchargement d'images de grande taille.Il est très étrange, tout en lisant les octets de flux toujours aucune réponse. Mon code est le suivant, toute suggestion est la bienvenue.

public class ImageTestActivity extends Activity { 

    public static final int IMAGE_BUFFER_SIZE = 8*1024; 
    public static final int MAX_REQUEST_WIDTH = 480; 
    public static final int MAX_REQUEST_HEIGHT = 480; 
    private static final String TAG = ImageTestActivity.class.getSimpleName(); 
    private static final int HTTP_CONNECT_TIMEOUT = 10000; 

    private static final int CONTENT_IMAGE_OFFSET = 80; 
    private Display mDisplay = null; 

    private ImageView mContentPic = null; 

    private Bitmap mContentPicBitmap = null; 

    private RefreshAsyncTask mRefreshTask = null; 

    /** Called when the activity is first created. */ 
    @Override 
    public void onCreate(Bundle savedInstanceState) { 
     super.onCreate(savedInstanceState); 
     setContentView(R.layout.main);   
     mContentPic = (ImageView)findViewById(R.id.wimessage_content_picture); 
     mDisplay = getWindowManager().getDefaultDisplay(); 
     mRefreshTask = new RefreshAsyncTask(); 
     mRefreshTask.execute("http://218.240.46.38/img/201206/28/-980416187.jpeg"); 
    }  

    private void initImageSetting(Bitmap bm) { 
     if (bm == null) { 
      return; 
     } 
     int scrWidth = mDisplay.getWidth(); 
     int scrHeight = mDisplay.getHeight(); 
     int imageHeight = bm.getHeight(); 
     int imageWidth = bm.getWidth(); 
     /*if (imageHeight*3 < imageWidth*2) { 
      * It is very strange, when the picture aspect ratio less than 3:2, 
      * execute the following code will cause the picture is not displayed 
      * 
      return; 
     }*/ 

     mContentPic.setAdjustViewBounds(true); 
     mContentPic.setMaxWidth(scrWidth - CONTENT_IMAGE_OFFSET); 
     if ((imageWidth <= scrWidth - CONTENT_IMAGE_OFFSET) || (imageHeight < scrHeight)) { 
      mContentPic.setMaxHeight(imageHeight); 
     } else { 
      mContentPic.setMaxHeight((int)((float)imageHeight * (scrWidth - CONTENT_IMAGE_OFFSET)/imageWidth));  
     } 
    } 

    public static byte[] getBytes(BufferedInputStream inStream) throws IOException { 
     ByteArrayOutputStream outStream = new ByteArrayOutputStream(); 
     BufferedOutputStream out = new BufferedOutputStream(outStream, IMAGE_BUFFER_SIZE); 
     byte[] buffer = new byte[IMAGE_BUFFER_SIZE]; 

     int len = inStream.read(buffer); 
     Log.i(TAG, "---start---"); 
     while (len != -1) { 
      Log.i(TAG, ((Integer)len).toString()); 
      try { 
       out.write(buffer, 0, len); 
      } catch (IndexOutOfBoundsException e) { 
       e.printStackTrace(); 
      } 
      len = inStream.read(buffer); 
     } 

     Log.i(TAG, "---end---"); 
     out.flush(); 
     out.close(); 
     inStream.close(); 

     return outStream.toByteArray(); 
    } 

    public static int calculateInSampleSize(BitmapFactory.Options options, 
      int reqWidth, int reqHeight) { 
     // Raw height and width of image 
     final int height = options.outHeight; 
     final int width = options.outWidth; 
     int inSampleSize = 1; 

     if (height > reqHeight || width > reqWidth) { 
      if (width > height) { 
       inSampleSize = Math.round((float) height/(float) reqHeight); 
      } else { 
       inSampleSize = Math.round((float) width/(float) reqWidth); 
      } 

      // This offers some additional logic in case the image has a strange 
      // aspect ratio. For example, a panorama may have a much larger 
      // width than height. In these cases the total pixels might still 
      // end up being too large to fit comfortably in memory, so we should 
      // be more aggressive with sample down the image (=larger 
      // inSampleSize). 

      final float totalPixels = width * height; 

      // Anything more than 2x the requested pixels we'll sample down 
      // further. 
      final float totalReqPixelsCap = reqWidth * reqHeight * 2; 

      while (totalPixels/(inSampleSize * inSampleSize) > totalReqPixelsCap) { 
       inSampleSize++; 
      } 
     } 
     return inSampleSize; 
    }  

    public static Bitmap loadImageFromURL(String urlPath) { 
     try { 
      URL url = new URL(urlPath); 
      HttpURLConnection connection = (HttpURLConnection) url.openConnection(); 
      connection.setRequestMethod("GET"); 
      connection.setConnectTimeout(HTTP_CONNECT_TIMEOUT); 
      int rspCode = connection.getResponseCode(); 
      if (rspCode == HttpStatus.SC_OK) { 
       //InputStream in = connection.getInputStream(); 
       Bitmap bitmap = null; 
       BufferedInputStream in = new BufferedInputStream(url.openStream(), IMAGE_BUFFER_SIZE); 
       byte[] data = getBytes(in); 
       in.close(); 
       if (data != null) { 
        try { 
         BitmapFactory.Options options = new BitmapFactory.Options(); 
         options.inJustDecodeBounds = true; 
         options.inSampleSize = calculateInSampleSize(options, MAX_REQUEST_WIDTH, MAX_REQUEST_HEIGHT); 
         options.inJustDecodeBounds = false; 
         bitmap = BitmapFactory.decodeByteArray(data, 0, data.length, options); 
        } catch (OutOfMemoryError e) { 
         e.printStackTrace(); 
        } 
       } else { 
        Log.i(TAG, "data == null"); 
       } 

       connection.disconnect();     
       return bitmap; 
      } else { 
       connection.disconnect(); 
       Log.i(TAG, "rspCode = " + rspCode); 
      } 
     } catch (MalformedURLException e) { 
      e.printStackTrace(); 
     } catch (IOException e) { 
      e.printStackTrace(); 
     } 

     return null; 
    } 

    private class RefreshAsyncTask extends AsyncTask<String, Boolean, Boolean> { 
     @Override 
     protected Boolean doInBackground(String... arg0) { 
      mContentPicBitmap = loadImageFromURL(arg0[0]); 
      return true; 
     } 

     @Override 
     protected void onPostExecute(Boolean result) { 
      super.onPostExecute(result); 
      if (mContentPicBitmap != null) { 
       initImageSetting(mContentPicBitmap); 
       mContentPic.setImageBitmap(mContentPicBitmap); 
      } 
     } 
    }  
} 

Answer 1

essayer ce que j'ai essayer avec ur des liens il me montre une image dans imageview

BitmapFactory.Options bmOptions; 
bmOptions = new BitmapFactory.Options(); 
bmOptions.inSampleSize = 1; 
bm = LoadImage("http://218.240.46.38/img/201206/28/-980416187.jpeg", bmOptions); 
imageview.setImageBitmap(bm); 

où methos LoadImage est comme indiqué ci-dessous

private Bitmap LoadImage(String URL, BitmapFactory.Options options){  
    Bitmap bitmap = null; 
    InputStream in = null;  
    try { 
     in = OpenHttpConnection(URL); 
     bitmap = BitmapFactory.decodeStream(in, null, options); 
     in.close(); 
    } catch (IOException e1) { 

    } 
    return bitmap;    
} 


private 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; 
} 

Answer 2

mise à jour:

utilisation connection.getInputStream() remplacer url.openStream():

BufferedInputStream in = new BufferedInputStream(connection.getInputStream(), IMAGE_BUFFER_SIZE); 

et votre méthode getBytes essayez ceci:

public static byte[] getBytes(BufferedInputStream inStream) throws IOException { 
    ByteArrayOutputStream out = new ByteArrayOutputStream(IMAGE_BUFFER_SIZE); 
    byte[] buffer = new byte[IMAGE_BUFFER_SIZE]; 

    int len = 0; 
    Log.i(TAG, "---start---"); 
    while ((len = inStream.read(buffer)) != -1) { 
     out.write(buffer, 0, len); 
     Log.i(TAG, "readed:" + len); 
    } 
    Log.i(TAG, "---end---"); 
    out.flush(); 
    inStream.close(); 

    return out.toByteArray(); 
} 

et dernière Ne pas oublier d'ajouter la permission:

<uses-permission android:name="android.permission.INTERNET"/> 
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>