Android 自定义imageview实现图片缩放实例详解

Android 自定义imageview实现图片缩放实例详解

 觉得这个自定义的imageview很好用 性能不错  所以拿出来分享给大家  因为不会做gif图  所以项目效果 就不好贴出来了  把代码贴出来

1.项目结构图

2.Compat.class

package com.suo.image;

import android.os.Build.VERSION;
import android.os.Build.VERSION_CODES;
import android.view.View;

public class Compat {

private static final int SIXTY_FPS_INTERVAL = 1000 / 60;

public static void postOnAnimation(View view, Runnable runnable) {
 if (VERSION.SDK_INT >= VERSION_CODES.JELLY_BEAN) {
  SDK16.postOnAnimation(view, runnable);
 } else {
  view.postDelayed(runnable, SIXTY_FPS_INTERVAL);
 }
}

}

3.HackyViewPager.class

package com.suo.image;

import android.content.Context;
import android.support.v4.view.ViewPager;
import android.util.AttributeSet;
import android.view.MotionEvent;

/**
* Hacky fix for Issue #4 and
* http://code.google.com/p/android/issues/detail?id=18990
*
* ScaleGestureDetector seems to mess up the touch events, which means that
* ViewGroups which make use of onInterceptTouchEvent throw a lot of
* IllegalArgumentException: pointerIndex out of range.
*
* There's not much I can do in my code for now, but we can mask the result by
* just catching the problem and ignoring it.
*
* @author Chris Banes
*/
public class HackyViewPager extends ViewPager {

public HackyViewPager(Context context) {
 super(context);
}

public HackyViewPager(Context context, AttributeSet attrs) {
 super(context, attrs);
 // TODO Auto-generated constructor stub
}

@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
 try {
  return super.onInterceptTouchEvent(ev);
 } catch (IllegalArgumentException e) {
  e.printStackTrace();
  return false;
 }
}

}

4.IScaleView.class

/*******************************************************************************
* Copyright 2011, 2012 Chris Banes.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*******************************************************************************/
package com.suo.image;

import android.graphics.RectF;
import android.view.View;
import android.widget.ImageView;

public interface IScaleView {
/**
 * Returns true if the ScaleView is set to allow zooming of Scales.
 *
 * @return true if the ScaleView allows zooming.
 */
boolean canZoom();

/**
 * Gets the Display Rectangle of the currently displayed Drawable. The
 * Rectangle is relative to this View and includes all scaling and
 * translations.
 *
 * @return - RectF of Displayed Drawable
 */
RectF getDisplayRect();

/**
 * @return The current minimum scale level. What this value represents depends on the current {@link android.widget.ImageView.ScaleType}.
 */
float getMinScale();

/**
 * @return The current middle scale level. What this value represents depends on the current {@link android.widget.ImageView.ScaleType}.
 */
float getMidScale();

/**
 * @return The current maximum scale level. What this value represents depends on the current {@link android.widget.ImageView.ScaleType}.
 */
float getMaxScale();

/**
 * Returns the current scale value
 *
 * @return float - current scale value
 */
float getScale();

/**
 * Return the current scale type in use by the ImageView.
 */
ImageView.ScaleType getScaleType();

/**
 * Whether to allow the ImageView's parent to intercept the touch event when the Scale is scroll to it's horizontal edge.
 */
void setAllowParentInterceptOnEdge(boolean allow);

/**
 * Sets the minimum scale level. What this value represents depends on the current {@link android.widget.ImageView.ScaleType}.
 */
void setMinScale(float minScale);

/**
 * Sets the middle scale level. What this value represents depends on the current {@link android.widget.ImageView.ScaleType}.
 */
void setMidScale(float midScale);

/**
 * Sets the maximum scale level. What this value represents depends on the current {@link android.widget.ImageView.ScaleType}.
 */
void setMaxScale(float maxScale);

/**
 * Register a callback to be invoked when the Scale displayed by this view is long-pressed.
 *
 * @param listener - Listener to be registered.
 */
void setOnLongClickListener(View.OnLongClickListener listener);

/**
 * Register a callback to be invoked when the Matrix has changed for this
 * View. An example would be the user panning or scaling the Scale.
 *
 * @param listener - Listener to be registered.
 */
void setOnMatrixChangeListener(ScaleViewAttacher.OnMatrixChangedListener listener);

/**
 * Register a callback to be invoked when the Scale displayed by this View
 * is tapped with a single tap.
 *
 * @param listener - Listener to be registered.
 */
void setOnScaleTapListener(ScaleViewAttacher.OnScaleTapListener listener);

/**
 * Register a callback to be invoked when the View is tapped with a single
 * tap.
 *
 * @param listener - Listener to be registered.
 */
void setOnViewTapListener(ScaleViewAttacher.OnViewTapListener listener);

/**
 * Controls how the image should be resized or moved to match the size of
 * the ImageView. Any scaling or panning will happen within the confines of
 * this {@link android.widget.ImageView.ScaleType}.
 *
 * @param scaleType - The desired scaling mode.
 */
void setScaleType(ImageView.ScaleType scaleType);

/**
 * Allows you to enable/disable the zoom functionality on the ImageView.
 * When disable the ImageView reverts to using the FIT_CENTER matrix.
 *
 * @param zoomable - Whether the zoom functionality is enabled.
 */
void setZoomable(boolean zoomable);

/**
 * Zooms to the specified scale, around the focal point given.
 *
 * @param scale - Scale to zoom to
 * @param focalX - X Focus Point
 * @param focalY - Y Focus Point
 */
void zoomTo(float scale, float focalX, float focalY);
}

5.ScaleView

/*******************************************************************************
* Copyright 2011, 2012 Chris Banes.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*******************************************************************************/
package com.suo.image;

import com.suo.image.ScaleViewAttacher.OnMatrixChangedListener;
import com.suo.image.ScaleViewAttacher.OnScaleTapListener;
import com.suo.image.ScaleViewAttacher.OnViewTapListener;

import android.content.Context;
import android.graphics.RectF;
import android.graphics.drawable.Drawable;
import android.net.Uri;
import android.util.AttributeSet;
import android.widget.ImageView;

public class ScaleView extends ImageView implements IScaleView {

@SuppressWarnings("unused")
private static final String TAG = "ScaleView";
private final ScaleViewAttacher mAttacher;

private ScaleType mPendingScaleType;

public ScaleView(Context context) {
 this(context, null);
 setZoomable(false);
}

public ScaleView(Context context, AttributeSet attr) {
 this(context, attr, 0);
}

public ScaleView(Context context, AttributeSet attr, int defStyle) {
 super(context, attr, defStyle);
 super.setScaleType(ScaleType.MATRIX);
 mAttacher = new ScaleViewAttacher(this);

if (null != mPendingScaleType) {
  setScaleType(mPendingScaleType);
  mPendingScaleType = null;
 }
}

public void setOnClickListener(OnClickListener listener){
 mAttacher.setOnClickLinstener(listener);
}

@Override
public boolean canZoom() {
 return mAttacher.canZoom();
}

@Override
public RectF getDisplayRect() {
 return mAttacher.getDisplayRect();
}

@Override
public float getMinScale() {
 return mAttacher.getMinScale();
}

@Override
public float getMidScale() {
 return mAttacher.getMidScale();
}

@Override
public float getMaxScale() {
 return mAttacher.getMaxScale();
}

@Override
public float getScale() {
 return mAttacher.getScale();
}

@Override
public ScaleType getScaleType() {
 return mAttacher.getScaleType();
}

@Override
public void setAllowParentInterceptOnEdge(boolean allow) {
 mAttacher.setAllowParentInterceptOnEdge(allow);
}

@Override
public void setMinScale(float minScale) {
 mAttacher.setMinScale(minScale);
}

@Override
public void setMidScale(float midScale) {
 mAttacher.setMidScale(midScale);
}

@Override
public void setMaxScale(float maxScale) {
 mAttacher.setMaxScale(maxScale);
}

@Override
// setImageBitmap calls through to this method
public void setImageDrawable(Drawable drawable) {
 super.setImageDrawable(drawable);
 if (null != mAttacher) {
  mAttacher.update();
 }
}

@Override
public void setImageResource(int resId) {
 super.setImageResource(resId);
 if (null != mAttacher) {
  mAttacher.update();
 }
}

@Override
public void setImageURI(Uri uri) {
 super.setImageURI(uri);
 if (null != mAttacher) {
  mAttacher.update();
 }
}

@Override
public void setOnMatrixChangeListener(OnMatrixChangedListener listener) {
 mAttacher.setOnMatrixChangeListener(listener);
}

@Override
public void setOnLongClickListener(OnLongClickListener l) {
 mAttacher.setOnLongClickListener(l);
}

@Override
public void setOnScaleTapListener(OnScaleTapListener listener) {
 mAttacher.setOnScaleTapListener(listener);
}

@Override
public void setOnViewTapListener(OnViewTapListener listener) {
 mAttacher.setOnViewTapListener(listener);
}

@Override
public void setScaleType(ScaleType scaleType) {
 if (null != mAttacher) {
  mAttacher.setScaleType(scaleType);
 } else {
  mPendingScaleType = scaleType;
 }
}

@Override
public void setZoomable(boolean zoomable) {
 mAttacher.setZoomable(zoomable);
}

@Override
public void zoomTo(float scale, float focalX, float focalY) {
 mAttacher.zoomTo(scale, focalX, focalY);
}

@Override
protected void onDetachedFromWindow() {
 mAttacher.cleanup();
 super.onDetachedFromWindow();
}

}

6.ScaleViewAttacher  这个是最关键的

/*******************************************************************************
* Copyright 2011, 2012 Chris Banes.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*******************************************************************************/
package com.suo.image;

import android.content.Context;
import android.graphics.Matrix;
import android.graphics.Matrix.ScaleToFit;
import android.graphics.RectF;
import android.graphics.drawable.Drawable;
import android.util.Log;
import android.view.GestureDetector;
import android.view.MotionEvent;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.View.OnLongClickListener;
import android.view.ViewTreeObserver;
import android.widget.ImageView;
import android.widget.ImageView.ScaleType;

import java.lang.ref.WeakReference;

public class ScaleViewAttacher implements IScaleView, View.OnTouchListener, VersionedGestureDetector.OnGestureListener,
 GestureDetector.OnDoubleTapListener, ViewTreeObserver.OnGlobalLayoutListener {

static final String LOG_TAG = "ScaleViewAttacher";

// let debug flag be dynamic, but still Proguard can be used to remove from release builds
static final boolean DEBUG = Log.isLoggable(LOG_TAG, Log.DEBUG);

static final int EDGE_NONE = -1;
static final int EDGE_LEFT = 0;
static final int EDGE_RIGHT = 1;
static final int EDGE_BOTH = 2;

public static final float DEFAULT_MAX_SCALE = 3.0f;
public static final float DEFAULT_MID_SCALE = 1.75f;
public static final float DEFAULT_MIN_SCALE = 1.0f;

private float mMinScale = DEFAULT_MIN_SCALE;
private float mMidScale = DEFAULT_MID_SCALE;
private float mMaxScale = DEFAULT_MAX_SCALE;

private boolean mAllowParentInterceptOnEdge = true;

private static void checkZoomLevels(float minZoom, float midZoom, float maxZoom) {
 if (minZoom >= midZoom) {
  throw new IllegalArgumentException("MinZoom should be less than MidZoom");
 } else if (midZoom >= maxZoom) {
  throw new IllegalArgumentException("MidZoom should be less than MaxZoom");
 }
}

/**
 * @return true if the ImageView exists, and it's Drawable existss
 */
private static boolean hasDrawable(ImageView imageView) {
 return null != imageView && null != imageView.getDrawable();
}

/**
 * @return true if the ScaleType is supported.
 */
private static boolean isSupportedScaleType(final ScaleType scaleType) {
 if (null == scaleType) {
  return false;
 }

switch (scaleType) {
  case MATRIX:
   throw new IllegalArgumentException(scaleType.name() + " is not supported in ScaleView");

default:
   return true;
 }
}

/**
 * Set's the ImageView's ScaleType to Matrix.
 */
private static void setImageViewScaleTypeMatrix(ImageView imageView) {
 if (null != imageView) {
  if (imageView instanceof ScaleView) {
   /**
    * ScaleView sets it's own ScaleType to Matrix, then diverts all
    * calls setScaleType to this.setScaleType. Basically we don't
    * need to do anything here
    */
  } else {
   imageView.setScaleType(ScaleType.MATRIX);
  }
 }
}

private WeakReference<ImageView> mImageView;
private ViewTreeObserver mViewTreeObserver;

// Gesture Detectors
private GestureDetector mGestureDetector;
private VersionedGestureDetector mScaleDragDetector;

// These are set so we don't keep allocating them on the heap
private final Matrix mBaseMatrix = new Matrix();
private final Matrix mDrawMatrix = new Matrix();
private final Matrix mSuppMatrix = new Matrix();
private final RectF mDisplayRect = new RectF();
private final float[] mMatrixValues = new float[9];

// Listeners
private OnMatrixChangedListener mMatrixChangeListener;
private OnScaleTapListener mScaleTapListener;
private OnViewTapListener mViewTapListener;
private OnLongClickListener mLongClickListener;

private int mIvTop, mIvRight, mIvBottom, mIvLeft;
private FlingRunnable mCurrentFlingRunnable;
private int mScrollEdge = EDGE_BOTH;

private boolean mZoomEnabled;
private ScaleType mScaleType = ScaleType.FIT_CENTER;
private OnClickListener onClickListener;

public ScaleViewAttacher(ImageView imageView) {
 mImageView = new WeakReference<ImageView>(imageView);

imageView.setOnTouchListener(this);

mViewTreeObserver = imageView.getViewTreeObserver();
 if (mViewTreeObserver != null) {
  mViewTreeObserver.addOnGlobalLayoutListener(this);
 }
 onClickListener = null;

// Make sure we using MATRIX Scale Type
 setImageViewScaleTypeMatrix(imageView);

if (!imageView.isInEditMode()) {
  // Create Gesture Detectors...
  mScaleDragDetector = VersionedGestureDetector.newInstance(imageView.getContext(), this);

mGestureDetector = new GestureDetector(imageView.getContext(),
    new GestureDetector.SimpleOnGestureListener() {

// forward long click listener
     @Override
     public void onLongPress(MotionEvent e) {
      if(null != mLongClickListener) {
       mLongClickListener.onLongClick(mImageView.get());
      }
     }});

mGestureDetector.setOnDoubleTapListener(this);

// Finally, update the UI so that we're zoomable
  setZoomable(true);
 }
}

@Override
public final boolean canZoom() {
 return mZoomEnabled;
}

/**
 * Clean-up the resources attached to this object. This needs to be called
 * when the ImageView is no longer used. A good example is from
 * {@link android.view.View#onDetachedFromWindow()} or from {@link android.app.Activity#onDestroy()}.
 * This is automatically called if you are using {@link ScaleView.co.senab.Scaleview.ScaleView}.
 */
@SuppressWarnings("deprecation")
public final void cleanup() {
 if (null != mImageView) {
  android.view.ViewTreeObserver obs = mImageView.get().getViewTreeObserver();
  if (obs != null) {
   obs.removeGlobalOnLayoutListener(this);
  }
 }
 mViewTreeObserver = null;

// Clear listeners too
 mMatrixChangeListener = null;
 mScaleTapListener = null;
 mViewTapListener = null;

// Finally, clear ImageView
 mImageView = null;
}

@Override
public final RectF getDisplayRect() {
 checkMatrixBounds();
 return getDisplayRect(getDisplayMatrix());
}

public final ImageView getImageView() {
 ImageView imageView = null;

if (null != mImageView) {
  imageView = mImageView.get();
 }

// If we don't have an ImageView, call cleanup()
 if (null == imageView) {
  cleanup();
//   throw new IllegalStateException(
//     "ImageView no longer exists. You should not use this ScaleViewAttacher any more.");
 }

return imageView;
}

@Override
public float getMinScale() {
 return mMinScale;
}

@Override
public float getMidScale() {
 return mMidScale;
}

@Override
public float getMaxScale() {
 return mMaxScale;
}

@Override
public final float getScale() {
 return getValue(mSuppMatrix, Matrix.MSCALE_X);
}

@Override
public final ScaleType getScaleType() {
 return mScaleType;
}

public final boolean onDoubleTap(MotionEvent ev) {
 try {
  float scale = getScale();
  float x = ev.getX();
  float y = ev.getY();

if (scale < mMidScale) {
   zoomTo(mMidScale, x, y);
  } else if (scale >= mMidScale && scale < mMaxScale) {
   zoomTo(mMaxScale, x, y);
  } else {
   zoomTo(mMinScale, x, y);
  }
 } catch (ArrayIndexOutOfBoundsException e) {
  // Can sometimes happen when getX() and getY() is called
 }

return true;
}

public final boolean onDoubleTapEvent(MotionEvent e) {
 // Wait for the confirmed onDoubleTap() instead
 return false;
}

public final void onDrag(float dx, float dy) {
 if (DEBUG) {
  Log.d(LOG_TAG, String.format("onDrag: dx: ％.2f. dy: ％.2f", dx, dy));
 }

ImageView imageView = getImageView();

if (null != imageView && hasDrawable(imageView)) {
  mSuppMatrix.postTranslate(dx, dy);
  checkAndDisplayMatrix();

/**
   * Here we decide whether to let the ImageView's parent to start
   * taking over the touch event.
   *
   * First we check whether this function is enabled. We never want the
   * parent to take over if we're scaling. We then check the edge we're
   * on, and the direction of the scroll (i.e. if we're pulling against
   * the edge, aka 'overscrolling', let the parent take over).
   */
  if (mAllowParentInterceptOnEdge && !mScaleDragDetector.isScaling()) {
   if (mScrollEdge == EDGE_BOTH || (mScrollEdge == EDGE_LEFT && dx >= 1f)
     || (mScrollEdge == EDGE_RIGHT && dx <= -1f)) {
     android.view.ViewParent vParent = imageView.getParent();
    if (vParent != null) {
     vParent.requestDisallowInterceptTouchEvent(false);
    }
   }
  }
 }
}

@Override
public final void onFling(float startX, float startY, float velocityX, float velocityY) {
 if (DEBUG) {
  Log.d(LOG_TAG, "onFling. sX: " + startX + " sY: " + startY + " Vx: " + velocityX + " Vy: " + velocityY);
 }

ImageView imageView = getImageView();
 if (hasDrawable(imageView)) {
  mCurrentFlingRunnable = new FlingRunnable(imageView.getContext());
  mCurrentFlingRunnable.fling(imageView.getWidth(), imageView.getHeight(), (int) velocityX, (int) velocityY);
  imageView.post(mCurrentFlingRunnable);
 }
}

@Override
public final void onGlobalLayout() {
 ImageView imageView = getImageView();

if (null != imageView && mZoomEnabled) {
  final int top = imageView.getTop();
  final int right = imageView.getRight();
  final int bottom = imageView.getBottom();
  final int left = imageView.getLeft();

/**
   * We need to check whether the ImageView's bounds have changed.
   * This would be easier if we targeted API 11+ as we could just use
   * View.OnLayoutChangeListener. Instead we have to replicate the
   * work, keeping track of the ImageView's bounds and then checking
   * if the values change.
   */
  if (top != mIvTop || bottom != mIvBottom || left != mIvLeft || right != mIvRight) {
   // Update our base matrix, as the bounds have changed
   updateBaseMatrix(imageView.getDrawable());

// Update values as something has changed
   mIvTop = top;
   mIvRight = right;
   mIvBottom = bottom;
   mIvLeft = left;
  }
 }
}

public final void setOnClickLinstener(OnClickListener listener){
 onClickListener = listener;
}

public final void onScale(float scaleFactor, float focusX, float focusY) {
 if (DEBUG) {
  Log.d(LOG_TAG, String.format("onScale: scale: ％.2f. fX: ％.2f. fY: ％.2f", scaleFactor, focusX, focusY));
 }

if (hasDrawable(getImageView()) && (getScale() < mMaxScale || scaleFactor < 1f)) {
  mSuppMatrix.postScale(scaleFactor, scaleFactor, focusX, focusY);
  checkAndDisplayMatrix();
 }
}

public final boolean onSingleTapConfirmed(MotionEvent e) {
 ImageView imageView = getImageView();

if (null != imageView) {
  if (null != mScaleTapListener) {
   final RectF displayRect = getDisplayRect();

if (null != displayRect) {
    final float x = e.getX(), y = e.getY();

// Check to see if the user tapped on the Scale
    if (displayRect.contains(x, y)) {

float xResult = (x - displayRect.left) / displayRect.width();
     float yResult = (y - displayRect.top) / displayRect.height();

mScaleTapListener.onScaleTap(imageView, xResult, yResult);
     return true;
    }
   }
  }
  if (null != mViewTapListener) {
   mViewTapListener.onViewTap(imageView, e.getX(), e.getY());
  }
 }

return false;
}

private float lastPosX, lastPosY;
private long firClick = 0;

@Override
public final boolean onTouch(View v, MotionEvent ev) {
 boolean handled = false;

if (mZoomEnabled) {
  switch (ev.getAction()) {
   case MotionEvent.ACTION_DOWN:
    // First, disable the Parent from intercepting the touch
    // event
    android.view.ViewParent vParent = v.getParent();
    if (vParent != null) {
     vParent.requestDisallowInterceptTouchEvent(true);
    }

lastPosX = ev.getX();
    lastPosY = ev.getY();
    // If we're flinging, and the user presses down, cancel
    // fling
    cancelFling();
    break;

case MotionEvent.ACTION_CANCEL:
   case MotionEvent.ACTION_UP:
    // If the user has zoomed less than min scale, zoom back
    // to min scale
    if (getScale() < mMinScale) {
     RectF rect = getDisplayRect();
     if (null != rect) {
      v.post(new AnimatedZoomRunnable(getScale(), mMinScale, rect.centerX(), rect.centerY()));
      handled = true;
     }
    }

if(ev.getX() == lastPosX && ev.getY() == lastPosY){
     long time = System.currentTimeMillis();
     if(time - firClick > 500){
      firClick = System.currentTimeMillis();
      if(onClickListener != null){
       onClickListener.onClick(getImageView());
      }
     }
    }
    break;
  }

// Check to see if the user double tapped
  if (null != mGestureDetector && mGestureDetector.onTouchEvent(ev)) {
   handled = true;
  }

// Finally, try the Scale/Drag detector
  if (null != mScaleDragDetector && mScaleDragDetector.onTouchEvent(ev)) {
   handled = true;
  }
 }

return handled;
}

@Override
public void setAllowParentInterceptOnEdge(boolean allow) {
 mAllowParentInterceptOnEdge = allow;
}

@Override
public void setMinScale(float minScale) {
 checkZoomLevels(minScale, mMidScale, mMaxScale);
 mMinScale = minScale;
}

@Override
public void setMidScale(float midScale) {
 checkZoomLevels(mMinScale, midScale, mMaxScale);
 mMidScale = midScale;
}

@Override
public void setMaxScale(float maxScale) {
 checkZoomLevels(mMinScale, mMidScale, maxScale);
 mMaxScale = maxScale;
}

@Override
public final void setOnLongClickListener(OnLongClickListener listener) {
 mLongClickListener = listener;
}

@Override
public final void setOnMatrixChangeListener(OnMatrixChangedListener listener) {
 mMatrixChangeListener = listener;
}

@Override
public final void setOnScaleTapListener(OnScaleTapListener listener) {
 mScaleTapListener = listener;
}

@Override
public final void setOnViewTapListener(OnViewTapListener listener) {
 mViewTapListener = listener;
}

@Override
public final void setScaleType(ScaleType scaleType) {
 if (isSupportedScaleType(scaleType) && scaleType != mScaleType) {
//   mScaleType = scaleType;

// Finally update
  update();
 }
}

@Override
public final void setZoomable(boolean zoomable) {
 mZoomEnabled = zoomable;
 update();
}

public final void update() {
 ImageView imageView = getImageView();

if (null != imageView) {
  if (mZoomEnabled) {
   // Make sure we using MATRIX Scale Type
   setImageViewScaleTypeMatrix(imageView);

// Update the base matrix using the current drawable
   updateBaseMatrix(imageView.getDrawable());
  } else {
   // Reset the Matrix...
   resetMatrix();
  }
 }
}

@Override
public final void zoomTo(float scale, float focalX, float focalY) {
 ImageView imageView = getImageView();

if (null != imageView) {
  imageView.post(new AnimatedZoomRunnable(getScale(), scale, focalX, focalY));
 }
}

protected Matrix getDisplayMatrix() {
 mDrawMatrix.set(mBaseMatrix);
 mDrawMatrix.postConcat(mSuppMatrix);
 return mDrawMatrix;
}

private void cancelFling() {
 if (null != mCurrentFlingRunnable) {
  mCurrentFlingRunnable.cancelFling();
  mCurrentFlingRunnable = null;
 }
}

/**
 * Helper method that simply checks the Matrix, and then displays the result
 */
private void checkAndDisplayMatrix() {
 checkMatrixBounds();
 setImageViewMatrix(getDisplayMatrix());
}

private void checkImageViewScaleType() {
 ImageView imageView = getImageView();

/**
  * ScaleView's getScaleType() will just divert to this.getScaleType() so
  * only call if we're not attached to a ScaleView.
  */
 if (null != imageView && !(imageView instanceof ScaleView)) {
  if (imageView.getScaleType() != ScaleType.MATRIX) {
   throw new IllegalStateException(
     "The ImageView's ScaleType has been changed since attaching a ScaleViewAttacher");
  }
 }
}

private void checkMatrixBounds() {
 final ImageView imageView = getImageView();
 if (null == imageView) {
  return;
 }

final RectF rect = getDisplayRect(getDisplayMatrix());
 if (null == rect) {
  return;
 }

final float height = rect.height(), width = rect.width();
 float deltaX = 0, deltaY = 0;

final int viewHeight = imageView.getHeight();
 if (height <= viewHeight) {
  switch (mScaleType) {
   case FIT_START:
    deltaY = -rect.top;
    break;
   case FIT_END:
    deltaY = viewHeight - height - rect.top;
    break;
   default:
    deltaY = (viewHeight - height) / 2 - rect.top;
    break;
  }
 } else if (rect.top > 0) {
  deltaY = -rect.top;
 } else if (rect.bottom < viewHeight) {
  deltaY = viewHeight - rect.bottom;
 }

final int viewWidth = imageView.getWidth();
 if (width <= viewWidth) {
  switch (mScaleType) {
   case FIT_START:
    deltaX = -rect.left;
    break;
   case FIT_END:
    deltaX = viewWidth - width - rect.left;
    break;
   default:
    deltaX = (viewWidth - width) / 2 - rect.left;
    break;
  }
  mScrollEdge = EDGE_BOTH;
 } else if (rect.left > 0) {
  mScrollEdge = EDGE_LEFT;
  deltaX = -rect.left;
 } else if (rect.right < viewWidth) {
  deltaX = viewWidth - rect.right;
  mScrollEdge = EDGE_RIGHT;
 } else {
  mScrollEdge = EDGE_NONE;
 }

// Finally actually translate the matrix
 mSuppMatrix.postTranslate(deltaX, deltaY);
}

/**
 * Helper method that maps the supplied Matrix to the current Drawable
 *
 * @param matrix - Matrix to map Drawable against
 * @return RectF - Displayed Rectangle
 */
private RectF getDisplayRect(Matrix matrix) {
 ImageView imageView = getImageView();

if (null != imageView) {
  Drawable d = imageView.getDrawable();
  if (null != d) {
   mDisplayRect.set(0, 0, d.getIntrinsicWidth(), d.getIntrinsicHeight());
   matrix.mapRect(mDisplayRect);
   return mDisplayRect;
  }
 }
 return null;
}

/**
 * Helper method that 'unpacks' a Matrix and returns the required value
 *
 * @param matrix - Matrix to unpack
 * @param whichValue - Which value from Matrix.M* to return
 * @return float - returned value
 */
private float getValue(Matrix matrix, int whichValue) {
 matrix.getValues(mMatrixValues);
 return mMatrixValues[whichValue];
}

/**
 * Resets the Matrix back to FIT_CENTER, and then displays it.s
 */
private void resetMatrix() {
 mSuppMatrix.reset();
 setImageViewMatrix(getDisplayMatrix());
 checkMatrixBounds();
}

private void setImageViewMatrix(Matrix matrix) {
 ImageView imageView = getImageView();
 if (null != imageView) {

checkImageViewScaleType();
  imageView.setImageMatrix(matrix);

// Call MatrixChangedListener if needed
  if (null != mMatrixChangeListener) {
   RectF displayRect = getDisplayRect(matrix);
   if (null != displayRect) {
    mMatrixChangeListener.onMatrixChanged(displayRect);
   }
  }
 }
}

/**
 * Calculate Matrix for FIT_CENTER
 *
 * @param d - Drawable being displayed
 */
private void updateBaseMatrix(Drawable d) {
 ImageView imageView = getImageView();
 if (null == imageView || null == d) {
  return;
 }

final float viewWidth = imageView.getWidth();
 final float viewHeight = imageView.getHeight();
 final int drawableWidth = d.getIntrinsicWidth();
 final int drawableHeight = d.getIntrinsicHeight();

mBaseMatrix.reset();

final float widthScale = viewWidth / drawableWidth;
 final float heightScale = viewHeight / drawableHeight;

if (mScaleType == ScaleType.CENTER) {
  mBaseMatrix.postTranslate((viewWidth - drawableWidth) / 2F, (viewHeight - drawableHeight) / 2F);

} else if (mScaleType == ScaleType.CENTER_CROP) {
  float scale = Math.max(widthScale, heightScale);
  mBaseMatrix.postScale(scale, scale);
  mBaseMatrix.postTranslate((viewWidth - drawableWidth * scale) / 2F,
    (viewHeight - drawableHeight * scale) / 2F);

} else if (mScaleType == ScaleType.CENTER_INSIDE) {
  float scale = Math.min(1.0f, Math.min(widthScale, heightScale));
  mBaseMatrix.postScale(scale, scale);
  mBaseMatrix.postTranslate((viewWidth - drawableWidth * scale) / 2F,
    (viewHeight - drawableHeight * scale) / 2F);

} else {
  RectF mTempSrc = new RectF(0, 0, drawableWidth, drawableHeight);
  RectF mTempDst = new RectF(0, 0, viewWidth, viewHeight);

switch (mScaleType) {
   case FIT_CENTER:
    mBaseMatrix.setRectToRect(mTempSrc, mTempDst, ScaleToFit.CENTER);
    break;

case FIT_START:
    mBaseMatrix.setRectToRect(mTempSrc, mTempDst, ScaleToFit.START);
    break;

case FIT_END:
    mBaseMatrix.setRectToRect(mTempSrc, mTempDst, ScaleToFit.END);
    break;

case FIT_XY:
    mBaseMatrix.setRectToRect(mTempSrc, mTempDst, ScaleToFit.FILL);
    break;

default:
    break;
  }
 }

resetMatrix();
}

/**
 * Interface definition for a callback to be invoked when the internal
 * Matrix has changed for this View.
 *
 * @author Chris Banes
 */
public static interface OnMatrixChangedListener {
 /**
  * Callback for when the Matrix displaying the Drawable has changed.
  * This could be because the View's bounds have changed, or the user has
  * zoomed.
  *
  * @param rect - Rectangle displaying the Drawable's new bounds.
  */
 void onMatrixChanged(RectF rect);
}

/**
 * Interface definition for a callback to be invoked when the Scale is
 * tapped with a single tap.
 *
 * @author Chris Banes
 */
public static interface OnScaleTapListener {

/**
  * A callback to receive where the user taps on a Scale. You will only
  * receive a callback if the user taps on the actual Scale, tapping on
  * 'whitespace' will be ignored.
  *
  * @param view - View the user tapped.
  * @param x - where the user tapped from the of the Drawable, as
  *   percentage of the Drawable width.
  * @param y - where the user tapped from the top of the Drawable, as
  *   percentage of the Drawable height.
  */
 void onScaleTap(View view, float x, float y);
}

/**
 * Interface definition for a callback to be invoked when the ImageView is
 * tapped with a single tap.
 *
 * @author Chris Banes
 */
public static interface OnViewTapListener {

/**
  * A callback to receive where the user taps on a ImageView. You will
  * receive a callback if the user taps anywhere on the view, tapping on
  * 'whitespace' will not be ignored.
  *
  * @param view - View the user tapped.
  * @param x - where the user tapped from the left of the View.
  * @param y - where the user tapped from the top of the View.
  */
 void onViewTap(View view, float x, float y);
}

private class AnimatedZoomRunnable implements Runnable {

// These are 'postScale' values, means they're compounded each iteration
 static final float ANIMATION_SCALE_PER_ITERATION_IN = 1.07f;
 static final float ANIMATION_SCALE_PER_ITERATION_OUT = 0.93f;

private final float mFocalX, mFocalY;
 private final float mTargetZoom;
 private final float mDeltaScale;

public AnimatedZoomRunnable(final float currentZoom, final float targetZoom, final float focalX,
   final float focalY) {
  mTargetZoom = targetZoom;
  mFocalX = focalX;
  mFocalY = focalY;

if (currentZoom < targetZoom) {
   mDeltaScale = ANIMATION_SCALE_PER_ITERATION_IN;
  } else {
   mDeltaScale = ANIMATION_SCALE_PER_ITERATION_OUT;
  }
 }

public void run() {
  ImageView imageView = getImageView();

if (null != imageView) {
   mSuppMatrix.postScale(mDeltaScale, mDeltaScale, mFocalX, mFocalY);
   checkAndDisplayMatrix();

final float currentScale = getScale();

if ((mDeltaScale > 1f && currentScale < mTargetZoom)
     || (mDeltaScale < 1f && mTargetZoom < currentScale)) {
    // We haven't hit our target scale yet, so post ourselves
    // again
    Compat.postOnAnimation(imageView, this);

} else {
    // We've scaled past our target zoom, so calculate the
    // necessary scale so we're back at target zoom
    final float delta = mTargetZoom / currentScale;
    mSuppMatrix.postScale(delta, delta, mFocalX, mFocalY);
    checkAndDisplayMatrix();
   }
  }
 }
}

private class FlingRunnable implements Runnable {

private final ScrollerProxy mScroller;
 private int mCurrentX, mCurrentY;

public FlingRunnable(Context context) {
  mScroller = ScrollerProxy.getScroller(context);
 }

public void cancelFling() {
  if (DEBUG) {
   Log.d(LOG_TAG, "Cancel Fling");
  }
  mScroller.forceFinished(true);
 }

public void fling(int viewWidth, int viewHeight, int velocityX, int velocityY) {
  final RectF rect = getDisplayRect();
  if (null == rect) {
   return;
  }

final int startX = Math.round(-rect.left);
  final int minX, maxX, minY, maxY;

if (viewWidth < rect.width()) {
   minX = 0;
   maxX = Math.round(rect.width() - viewWidth);
  } else {
   minX = maxX = startX;
  }

final int startY = Math.round(-rect.top);
  if (viewHeight < rect.height()) {
   minY = 0;
   maxY = Math.round(rect.height() - viewHeight);
  } else {
   minY = maxY = startY;
  }

mCurrentX = startX;
  mCurrentY = startY;

if (DEBUG) {
   Log.d(LOG_TAG, "fling. StartX:" + startX + " StartY:" + startY + " MaxX:" + maxX + " MaxY:" + maxY);
  }

// If we actually can move, fling the scroller
  if (startX != maxX || startY != maxY) {
   mScroller.fling(startX, startY, velocityX, velocityY, minX, maxX, minY, maxY, 0, 0);
  }
 }

@Override
 public void run() {
  ImageView imageView = getImageView();
  if (null != imageView && mScroller.computeScrollOffset()) {

final int newX = mScroller.getCurrX();
   final int newY = mScroller.getCurrY();

if (DEBUG) {
    Log.d(LOG_TAG, "fling run(). CurrentX:" + mCurrentX + " CurrentY:" + mCurrentY + " NewX:" + newX
      + " NewY:" + newY);
   }

mSuppMatrix.postTranslate(mCurrentX - newX, mCurrentY - newY);
   setImageViewMatrix(getDisplayMatrix());

mCurrentX = newX;
   mCurrentY = newY;

// Post On animation
   Compat.postOnAnimation(imageView, this);
  }
 }
}
}

7.ScrollerProxy

/*******************************************************************************
* Copyright 2011, 2012 Chris Banes.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*******************************************************************************/
package com.suo.image;

import android.annotation.TargetApi;
import android.content.Context;
import android.os.Build.VERSION;
import android.os.Build.VERSION_CODES;
import android.widget.OverScroller;
import android.widget.Scroller;

public abstract class ScrollerProxy {

public static ScrollerProxy getScroller(Context context) {
 if (VERSION.SDK_INT < VERSION_CODES.GINGERBREAD) {
  return new PreGingerScroller(context);
 } else {
  return new GingerScroller(context);
 }
}

public abstract boolean computeScrollOffset();

public abstract void fling(int startX, int startY, int velocityX, int velocityY, int minX, int maxX, int minY,
  int maxY, int overX, int overY);

public abstract void forceFinished(boolean finished);

public abstract int getCurrX();

public abstract int getCurrY();

@TargetApi(9)
private static class GingerScroller extends ScrollerProxy {

private OverScroller mScroller;

public GingerScroller(Context context) {
  mScroller = new OverScroller(context);
 }

@Override
 public boolean computeScrollOffset() {
  return mScroller.computeScrollOffset();
 }

@Override
 public void fling(int startX, int startY, int velocityX, int velocityY, int minX, int maxX, int minY, int maxY,
   int overX, int overY) {
  mScroller.fling(startX, startY, velocityX, velocityY, minX, maxX, minY, maxY, overX, overY);
 }

@Override
 public void forceFinished(boolean finished) {
  mScroller.forceFinished(finished);
 }

@Override
 public int getCurrX() {
  return mScroller.getCurrX();
 }

@Override
 public int getCurrY() {
  return mScroller.getCurrY();
 }
}

private static class PreGingerScroller extends ScrollerProxy {

private Scroller mScroller;

public PreGingerScroller(Context context) {
  mScroller = new Scroller(context);
 }

@Override
 public boolean computeScrollOffset() {
  return mScroller.computeScrollOffset();
 }

@Override
 public void fling(int startX, int startY, int velocityX, int velocityY, int minX, int maxX, int minY, int maxY,
   int overX, int overY) {
  mScroller.fling(startX, startY, velocityX, velocityY, minX, maxX, minY, maxY);
 }

@Override
 public void forceFinished(boolean finished) {
  mScroller.forceFinished(finished);
 }

@Override
 public int getCurrX() {
  return mScroller.getCurrX();
 }

@Override
 public int getCurrY() {
  return mScroller.getCurrY();
 }
}
}

8.SDK16

/*******************************************************************************
* Copyright 2011, 2012 Chris Banes.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*******************************************************************************/
package com.suo.image;

import android.annotation.TargetApi;
import android.view.View;

@TargetApi(16)
public class SDK16 {

public static void postOnAnimation(View view, Runnable r) {
 view.postOnAnimation(r);
}

}

9.VersionedGestureDetector

package com.suo.image;

/*******************************************************************************
* Copyright 2011, 2012 Chris Banes.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*******************************************************************************/

import android.annotation.TargetApi;
import android.content.Context;
import android.os.Build;
import android.view.MotionEvent;
import android.view.ScaleGestureDetector;
import android.view.ScaleGestureDetector.OnScaleGestureListener;
import android.view.VelocityTracker;
import android.view.ViewConfiguration;

public abstract class VersionedGestureDetector {
static final String LOG_TAG = "VersionedGestureDetector";
OnGestureListener mListener;

public static VersionedGestureDetector newInstance(Context context, OnGestureListener listener) {
 final int sdkVersion = Build.VERSION.SDK_INT;
 VersionedGestureDetector detector = null;

if (sdkVersion < Build.VERSION_CODES.ECLAIR) {
  detector = new CupcakeDetector(context);
 } else if (sdkVersion < Build.VERSION_CODES.FROYO) {
  detector = new EclairDetector(context);
 } else {
  detector = new FroyoDetector(context);
 }

detector.mListener = listener;

return detector;
}

public abstract boolean onTouchEvent(MotionEvent ev);

public abstract boolean isScaling();

public static interface OnGestureListener {
 public void onDrag(float dx, float dy);

public void onFling(float startX, float startY, float velocityX, float velocityY);

public void onScale(float scaleFactor, float focusX, float focusY);
}

private static class CupcakeDetector extends VersionedGestureDetector {

float mLastTouchX;
 float mLastTouchY;
 final float mTouchSlop;
 final float mMinimumVelocity;

public CupcakeDetector(Context context) {
  final ViewConfiguration configuration = ViewConfiguration.get(context);
  mMinimumVelocity = configuration.getScaledMinimumFlingVelocity();
  mTouchSlop = configuration.getScaledTouchSlop();
 }

private VelocityTracker mVelocityTracker;
 private boolean mIsDragging;

float getActiveX(MotionEvent ev) {
  return ev.getX();
 }

float getActiveY(MotionEvent ev) {
  return ev.getY();
 }

public boolean isScaling() {
  return false;
 }

@Override
 public boolean onTouchEvent(MotionEvent ev) {
  boolean result = true;
  switch (ev.getAction()) {
   case MotionEvent.ACTION_DOWN: {
    mVelocityTracker = VelocityTracker.obtain();
    if (mVelocityTracker != null) {
     mVelocityTracker.addMovement(ev);
    }

mLastTouchX = getActiveX(ev);
    mLastTouchY = getActiveY(ev);
    mIsDragging = false;
    break;
   }

case MotionEvent.ACTION_MOVE: {
    final float x = getActiveX(ev);
    final float y = getActiveY(ev);
    final float dx = x - mLastTouchX, dy = y - mLastTouchY;

if (!mIsDragging) {
     // Use Pythagoras to see if drag length is larger than
     // touch slop
     mIsDragging = Math.sqrt((dx * dx) + (dy * dy)) >= mTouchSlop;
    }

if (mIsDragging) {
     mListener.onDrag(dx, dy);
     mLastTouchX = x;
     mLastTouchY = y;

if (null != mVelocityTracker) {
      mVelocityTracker.addMovement(ev);
     }
    }
    break;
   }

case MotionEvent.ACTION_CANCEL: {
    // Recycle Velocity Tracker

if (null != mVelocityTracker) {
     mVelocityTracker.recycle();
     mVelocityTracker = null;
    }
    break;
   }

case MotionEvent.ACTION_UP: {
    if (mIsDragging) {
     if (null != mVelocityTracker) {
      mLastTouchX = getActiveX(ev);
      mLastTouchY = getActiveY(ev);

// Compute velocity within the last 1000ms
      mVelocityTracker.addMovement(ev);
      mVelocityTracker.computeCurrentVelocity(1000);

final float vX = mVelocityTracker.getXVelocity(), vY = mVelocityTracker.getYVelocity();

// If the velocity is greater than minVelocity, call
      // listener
      if (Math.max(Math.abs(vX), Math.abs(vY)) >= mMinimumVelocity) {
       mListener.onFling(mLastTouchX, mLastTouchY, -vX, -vY);
      }
     }
    }

// Recycle Velocity Tracker
    if (null != mVelocityTracker) {
     mVelocityTracker.recycle();
     mVelocityTracker = null;
    }

break;
   }
  }

return result;
 }
}

@TargetApi(5)
private static class EclairDetector extends CupcakeDetector {
 private static final int INVALID_POINTER_ID = -1;
 private int mActivePointerId = INVALID_POINTER_ID;
 private int mActivePointerIndex = 0;

public EclairDetector(Context context) {
  super(context);
 }

@Override
 float getActiveX(MotionEvent ev) {
  try {
   return ev.getX(mActivePointerIndex);
  } catch (Exception e) {
   return ev.getX();
  }
 }

@Override
 float getActiveY(MotionEvent ev) {
  try {
   return ev.getY(mActivePointerIndex);
  } catch (Exception e) {
   return ev.getY();
  }
 }

@Override
 public boolean onTouchEvent(MotionEvent ev) {
  final int action = ev.getAction();
  switch (action & MotionEvent.ACTION_MASK) {
   case MotionEvent.ACTION_DOWN:
    mActivePointerId = ev.getPointerId(0);
    break;
   case MotionEvent.ACTION_CANCEL:
   case MotionEvent.ACTION_UP:
    mActivePointerId = INVALID_POINTER_ID;
    break;
   case MotionEvent.ACTION_POINTER_UP:
    final int pointerIndex = (ev.getAction() & MotionEvent.ACTION_POINTER_INDEX_MASK) >> MotionEvent.ACTION_POINTER_INDEX_SHIFT;
    final int pointerId = ev.getPointerId(pointerIndex);
    if (pointerId == mActivePointerId) {
     // This was our active pointer going up. Choose a new
     // active pointer and adjust accordingly.
     final int newPointerIndex = pointerIndex == 0 ? 1 : 0;
     mActivePointerId = ev.getPointerId(newPointerIndex);
     mLastTouchX = ev.getX(newPointerIndex);
     mLastTouchY = ev.getY(newPointerIndex);
    }
    break;
  }

mActivePointerIndex = ev.findPointerIndex(mActivePointerId != INVALID_POINTER_ID ? mActivePointerId : 0);
  return super.onTouchEvent(ev);
 }
}

@TargetApi(8)
private static class FroyoDetector extends EclairDetector {

private final ScaleGestureDetector mDetector;

// Needs to be an inner class so that we don't hit
 // VerifyError's on API 4.
 private final OnScaleGestureListener mScaleListener = new OnScaleGestureListener() {

@Override
  public boolean onScale(ScaleGestureDetector detector) {
   mListener.onScale(detector.getScaleFactor(), detector.getFocusX(), detector.getFocusY());
   return true;
  }

@Override
  public boolean onScaleBegin(ScaleGestureDetector detector) {
   return true;
  }

@Override
  public void onScaleEnd(ScaleGestureDetector detector) {
   // NO-OP
  }
 };

public FroyoDetector(Context context) {
  super(context);
  mDetector = new ScaleGestureDetector(context, mScaleListener);
 }

@Override
 public boolean isScaling() {
  return mDetector.isInProgress();
 }

@Override
 public boolean onTouchEvent(MotionEvent ev) {
  mDetector.onTouchEvent(ev);
  return super.onTouchEvent(ev);
 }

}
}

10.MainActivity 

package com.suo.myimage;

import android.os.Bundle;
import android.app.Activity;
import android.view.Menu;

public class MainActivity extends Activity {

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

@Override
public boolean onCreateOptionsMenu(Menu menu) {
 // Inflate the menu; this adds items to the action bar if it is present.
 getMenuInflater().inflate(R.menu.activity_main, menu);
 return true;
}

}

activity_main.xml

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity" >

<TextView
 android:layout_width="wrap_content"
 android:layout_height="wrap_content"
 android:layout_centerHorizontal="true"
 android:layout_centerVertical="true"
 android:text="@string/hello_world" />

<com.suo.image.ScaleView
 android:layout_width="match_parent"
 android:layout_height="match_parent"
 android:src="@drawable/a"/>

</RelativeLayout>

感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！