Question

Hi guys. I have a problem when downloading large size images.It’s very strange, while read bytes from stream always no response.
My code is as follows, any suggestion is welcome.

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

try this i have try with ur links it show me an image in 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);

where methos LoadImage is as given below

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