title: How to show image in ViewPager in Android?
body: <p>I have an images in my <code>GridView</code>. Now I want to show the <code>image</code> in <code>ViewPager</code> in <code>next Activity</code>.I am trying to set a <code>bitmap</code> to that <code>imageView</code> (view) in another <code>class</code>.But after run the app image is not show in <code>ViewPager</code>.Thanks to appreciate.</p>
  
  <p>Hare is code</p>
  
  <pre><code>public class FullScreenViewActivity extends Activity
  {
  
      private FullScreenImageAdapter adapter;
      private ViewPager viewPager;
      private ArrayList&lt;String&gt; mThumbIds = new ArrayList&lt;String&gt;();
  
      @SuppressWarnings("unchecked")
      @Override
      protected void onCreate(Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);
          setContentView(R.layout.activity_fullscreen_view);
  
          viewPager = (ViewPager) findViewById(R.id.pager);
          Intent i = getIntent();
  
          mThumbIds = (ArrayList&lt;String&gt;) this.getIntent().getSerializableExtra("data");
          System.out.println("mThumbIds = " + mThumbIds);
  
          int  position = i.getIntExtra("id", 0);
          System.out.println("position = " + position);
  
          adapter = new FullScreenImageAdapter(this , mThumbIds);
          viewPager.setAdapter(adapter);
          viewPager.setCurrentItem(position);
      }
  }
  </code></pre>
  
  <p>Here is Adapter class</p>
  
  <pre><code>public class FullScreenImageAdapter extends PagerAdapter implements OnTouchListener{
  
      private Activity _activity;
      private ArrayList&lt;String&gt; _imagePaths;
      private LayoutInflater inflater;
      Bitmap bitmap;
  
      // constructor
      public FullScreenImageAdapter(Activity activity,ArrayList&lt;String&gt; imagePaths) {
          this._activity = activity;
          this._imagePaths = imagePaths;
      }
  
      @Override
      public int getCount() {
          return this._imagePaths.size();
      }
  
      @Override
      public boolean isViewFromObject(View view, Object object) {
          return view == ((RelativeLayout) object);
      }
  
  
      @Override
      public Object instantiateItem(ViewGroup container, int position) {
  
          Button btnClose;
          Button btnEdit;
          TouchImageView imgDisplay;
  
  
          inflater = (LayoutInflater) _activity.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
          View viewLayout = inflater.inflate(R.layout.layout_fullscreen_image, container, false);
  
          imgDisplay = (TouchImageView) viewLayout.findViewById(R.id.imgDisplay);
          imgDisplay.setOnTouchListener((OnTouchListener) this);
  
          BitmapFactory.Options options = new BitmapFactory.Options();
          options.inPreferredConfig = Bitmap.Config.ARGB_8888;
          options.inSampleSize = 8;
          bitmap = BitmapFactory.decodeFile(_imagePaths.get(position), options);
  
  
          imgDisplay.setImageBitmap(bitmap);
  
  
          btnClose = (Button) viewLayout.findViewById(R.id.btnClose);
          btnClose.setOnClickListener(new View.OnClickListener() {            
              @Override
              public void onClick(View v) {
                  _activity.finish();
              }
          });
  
  
  
          ((ViewPager) container).addView(viewLayout); 
          return viewLayout;
      }
  
  
       @Override
          public void destroyItem(ViewGroup container, int position, Object object) {
              ((ViewPager) container).removeView((RelativeLayout) object);
  
          }
  
  
      public boolean onTouch(View arg0, MotionEvent arg1) {
          // TODO Auto-generated method stub
          return false;
      }
  }
  </code></pre>
  
  <p>Here is TouchImageView code</p>
  
  <pre><code>public class TouchImageView extends ImageView {
  
          Matrix matrix;
  
          // We can be in one of these 3 states
          static final int NONE = 0;
          static final int DRAG = 1;
          static final int ZOOM = 2;
          int mode = NONE;
  
          // Remember some things for zooming
          PointF last = new PointF();
          PointF start = new PointF();
          float minScale = 1f;
          float maxScale = 3f;
          float[] m;
  
          int viewWidth, viewHeight;
          static final int CLICK = 3;
          float saveScale = 1f;
          protected float origWidth, origHeight;
          int oldMeasuredWidth, oldMeasuredHeight;
  
          ScaleGestureDetector mScaleDetector;
  
          Context context;
  
          public TouchImageView(Context context) {
              super(context);
              sharedConstructing(context);
          }
  
          public TouchImageView(Context context, AttributeSet attrs) {
              super(context, attrs);
              sharedConstructing(context);
          }
  
          private void sharedConstructing(Context context) {
              super.setClickable(true);
              this.context = context;
              mScaleDetector = new ScaleGestureDetector(context, new ScaleListener());
              matrix = new Matrix();
              m = new float[9];
              setImageMatrix(matrix);
              setScaleType(ScaleType.MATRIX);
  
              setOnTouchListener(new OnTouchListener() {
  
                  @Override
                  public boolean onTouch(View v, MotionEvent event) {
                      mScaleDetector.onTouchEvent(event);
                      PointF curr = new PointF(event.getX(), event.getY());
  
                      switch (event.getAction()) {
                      case MotionEvent.ACTION_DOWN:
                          last.set(curr);
                          start.set(last);
                          mode = DRAG;
                          break;
  
                      case MotionEvent.ACTION_MOVE:
                          if (mode == DRAG) {
                              float deltaX = curr.x - last.x;
                              float deltaY = curr.y - last.y;
                              float fixTransX = getFixDragTrans(deltaX, viewWidth,
                                      origWidth * saveScale);
                              float fixTransY = getFixDragTrans(deltaY, viewHeight,
                                      origHeight * saveScale);
                              matrix.postTranslate(fixTransX, fixTransY);
                              fixTrans();
                              last.set(curr.x, curr.y);
                          }
                          break;
  
                      case MotionEvent.ACTION_UP:
                          mode = NONE;
                          int xDiff = (int) Math.abs(curr.x - start.x);
                          int yDiff = (int) Math.abs(curr.y - start.y);
                          if (xDiff &lt; CLICK &amp;&amp; yDiff &lt; CLICK)
                              performClick();
                          break;
  
                      case MotionEvent.ACTION_POINTER_UP:
                          mode = NONE;
                          break;
                      }
  
                      setImageMatrix(matrix);
                      invalidate();
                      return true; // indicate event was handled
                  }
  
              });
          }
  
          public void setMaxZoom(float x) {
              maxScale = x;
          }
  
          private class ScaleListener extends
                  ScaleGestureDetector.SimpleOnScaleGestureListener {
              @Override
              public boolean onScaleBegin(ScaleGestureDetector detector) {
                  mode = ZOOM;
                  return true;
              }
  
              @Override
              public boolean onScale(ScaleGestureDetector detector) {
                  float mScaleFactor = detector.getScaleFactor();
                  float origScale = saveScale;
                  saveScale *= mScaleFactor;
                  if (saveScale &gt; maxScale) {
                      saveScale = maxScale;
                      mScaleFactor = maxScale / origScale;
                  } else if (saveScale &lt; minScale) {
                      saveScale = minScale;
                      mScaleFactor = minScale / origScale;
                  }
  
                  if (origWidth * saveScale &lt;= viewWidth
                          || origHeight * saveScale &lt;= viewHeight)
                      matrix.postScale(mScaleFactor, mScaleFactor, viewWidth / 2,
                              viewHeight / 2);
                  else
                      matrix.postScale(mScaleFactor, mScaleFactor,
                              detector.getFocusX(), detector.getFocusY());
  
                  fixTrans();
                  return true;
              }
          }
  
          void fixTrans() {
              matrix.getValues(m);
              float transX = m[Matrix.MTRANS_X];
              float transY = m[Matrix.MTRANS_Y];
  
              float fixTransX = getFixTrans(transX, viewWidth, origWidth * saveScale);
              float fixTransY = getFixTrans(transY, viewHeight, origHeight
                      * saveScale);
  
              if (fixTransX != 0 || fixTransY != 0)
                  matrix.postTranslate(fixTransX, fixTransY);
          }
  
          float getFixTrans(float trans, float viewSize, float contentSize) {
              float minTrans, maxTrans;
  
              if (contentSize &lt;= viewSize) {
                  minTrans = 0;
                  maxTrans = viewSize - contentSize;
              } else {
                  minTrans = viewSize - contentSize;
                  maxTrans = 0;
              }
  
              if (trans &lt; minTrans)
                  return -trans + minTrans;
              if (trans &gt; maxTrans)
                  return -trans + maxTrans;
              return 0;
          }
  
          float getFixDragTrans(float delta, float viewSize, float contentSize) {
              if (contentSize &lt;= viewSize) {
                  return 0;
              }
              return delta;
          }
  
          @Override
          protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
              super.onMeasure(widthMeasureSpec, heightMeasureSpec);
              viewWidth = MeasureSpec.getSize(widthMeasureSpec);
              viewHeight = MeasureSpec.getSize(heightMeasureSpec);
  
              //
              // Rescales image on rotation
              //
              if (oldMeasuredHeight == viewWidth &amp;&amp; oldMeasuredHeight == viewHeight
                      || viewWidth == 0 || viewHeight == 0)
                  return;
              oldMeasuredHeight = viewHeight;
              oldMeasuredWidth = viewWidth;
  
              if (saveScale == 1) {
                  // Fit to screen.
                  float scale;
  
                  Drawable drawable = getDrawable();
                  if (drawable == null || drawable.getIntrinsicWidth() == 0
                          || drawable.getIntrinsicHeight() == 0)
                      return;
                  int bmWidth = drawable.getIntrinsicWidth();
                  int bmHeight = drawable.getIntrinsicHeight();
  
                  Log.d("bmSize", "bmWidth: " + bmWidth + " bmHeight : " + bmHeight);
  
                  float scaleX = (float) viewWidth / (float) bmWidth;
                  float scaleY = (float) viewHeight / (float) bmHeight;
                  scale = Math.min(scaleX, scaleY);
                  matrix.setScale(scale, scale);
  
                  // Center the image
                  float redundantYSpace = (float) viewHeight
                          - (scale * (float) bmHeight);
                  float redundantXSpace = (float) viewWidth
                          - (scale * (float) bmWidth);
                  redundantYSpace /= (float) 2;
                  redundantXSpace /= (float) 2;
  
                  matrix.postTranslate(redundantXSpace, redundantYSpace);
  
                  origWidth = viewWidth - 2 * redundantXSpace;
                  origHeight = viewHeight - 2 * redundantYSpace;
                  setImageMatrix(matrix);
              }
              fixTrans();
          }
      }
  </code></pre>