title: Image orientation is changed on ImageView When fetching from Gallery and upload
body: <p>I simply want to fetch Images from gallery and upload then download from Server and set it on an ImageView on Activity. The image View is placed at the center of the Activity. All is working fine just a screenOrientation variation problem with adjusting Image on ImageView after fetching it from Server, download and set to image View. Please have a look over code what i am using to download Image Bitmap from Server and set it to required ImageView. It usually display rotated Image in case of portrait capturing image from Gallery or Camera. Please let me know if i am missing anything in my Code.</p>
  
  <pre><code>package com.fedorvlasov.lazylist;
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileNotFoundException;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.net.HttpURLConnection;
  import java.net.URL;
  import java.util.Collections;
  import java.util.Map;
  import java.util.WeakHashMap;
  import java.util.concurrent.ExecutorService;
  import java.util.concurrent.Executors;
  import com.example.qlique.R;
  import android.os.Handler;
  import android.content.Context;
  import android.graphics.Bitmap;
  import android.graphics.BitmapFactory;
  import android.widget.ImageView;
  
  public class ImageLoader {
      MemoryCache memoryCache = new MemoryCache();
      FileCache fileCache;
      private Map&lt;ImageView, String&gt; imageViews = Collections
              .synchronizedMap(new WeakHashMap&lt;ImageView, String&gt;());
      ExecutorService executorService;
      Handler handler = new Handler();// handler to display images in UI thread
  
      public ImageLoader(Context context) {
          fileCache = new FileCache(context);
          executorService = Executors.newFixedThreadPool(5);
      }
  
      final int stub_id = R.drawable.stub;
  
      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();
              conn.disconnect();
              bitmap = decodeFile(f);
              return bitmap;
          } catch (Throwable ex) {
              ex.printStackTrace();
              if (ex instanceof OutOfMemoryError)
                  memoryCache.clear();
              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;
              FileInputStream stream1 = new FileInputStream(f);
              BitmapFactory.decodeStream(stream1, null, o);
              stream1.close();
  
              // 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 &lt; REQUIRED_SIZE
                          || height_tmp / 2 &lt; REQUIRED_SIZE)
                      break;
                  width_tmp /= 2;
                  height_tmp /= 2;
                  scale *= 2;
              }
  
              // decode with inSampleSize
              BitmapFactory.Options o2 = new BitmapFactory.Options();
              o2.inSampleSize = scale;
              FileInputStream stream2 = new FileInputStream(f);
              Bitmap bitmap = BitmapFactory.decodeStream(stream2, null, o2);
              stream2.close();
              return bitmap;
          } catch (FileNotFoundException e) {
          } catch (IOException 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;
          }
      }
  
      class PhotosLoader implements Runnable {
          PhotoToLoad photoToLoad;
  
          PhotosLoader(PhotoToLoad photoToLoad) {
              this.photoToLoad = photoToLoad;
          }
  
          @Override
          public void run() {
              try {
                  if (imageViewReused(photoToLoad))
                      return;
                  Bitmap bmp = getBitmap(photoToLoad.url);
                  memoryCache.put(photoToLoad.url, bmp);
                  if (imageViewReused(photoToLoad))
                      return;
                  BitmapDisplayer bd = new BitmapDisplayer(bmp, photoToLoad);
                  handler.post(bd);
              } catch (Throwable th) {
                  th.printStackTrace();
              }
          }
      }
  
      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();
      }
  }
  </code></pre>