Android PinchZoom覆盖按钮

我对某个活动进行了收缩缩放，但它当前隐藏了按钮，当我切换这些按钮时，按钮显示，但收缩缩放中断

该活动显示了一个超过两页的教学图像，我希望用户能够点击zoom阅读文件，然后单击按钮查看第二页

我也考虑过使用滑动手势，但我对Android开发非常陌生

我是否可以显示我的按钮并在同一活动上保持收缩缩放

下面是我的班级：

import android.content.Intent;
import android.os.Bundle;
import android.app.Activity;
import android.view.Menu;
import android.view.View;

public class specbuttons extends Activity {

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

    TouchImageBroken img = new TouchImageBroken(this);
    img.setImageResource(R.drawable.specpc14p2);
    img.setMaxZoom(10f);
    setContentView(img);


}




}

以下是我的活动：

<?xml version="1.0" encoding="utf-8"?>
<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"
android:paddingBottom="@dimen/activity_vertical_margin"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
tools:context="com.heservices.heapp.heservices.specbuttons">

<android.support.v4.view.ViewPager
    android:id="@+id/viewpager"
    android:layout_height="500dp"
    android:layout_width="match_parent"/>

<ImageView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:id="@+id/imageView7"
    android:src="@drawable/specpc14p2"
    android:layout_alignParentTop="true"
    android:layout_alignParentEnd="true" />

<Button
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text=">"
    android:id="@+id/button3"
    android:layout_alignBottom="@+id/imageView7"
    android:layout_alignParentEnd="true" />

</RelativeLayout>

以下是我的Pinch Zoom课程供参考：

import android.content.Context;
import android.graphics.Matrix;
import android.graphics.PointF;
import android.graphics.drawable.Drawable;
import android.util.AttributeSet;
import android.util.Log;
import android.view.MotionEvent;
import android.view.ScaleGestureDetector;
import android.view.View;
import android.widget.ImageView;

public class TouchImageBroken 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 TouchImageBroken(Context context) {
    super(context);
    sharedConstructing(context);
}

public TouchImageBroken(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 < CLICK && yDiff < 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 > maxScale) {

            saveScale = maxScale;

            mScaleFactor = maxScale / origScale;

        } else if (saveScale < minScale) {

            saveScale = minScale;

            mScaleFactor = minScale / origScale;

        }

        if (origWidth * saveScale <= viewWidth || origHeight * saveScale <= 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 <= viewSize) {

        minTrans = 0;

        maxTrans = viewSize - contentSize;

    } else {

        minTrans = viewSize - contentSize;

        maxTrans = 0;

    }

    if (trans < minTrans)

        return -trans + minTrans;

    if (trans > maxTrans)

        return -trans + maxTrans;

    return 0;

}

float getFixDragTrans(float delta, float viewSize, float contentSize) {

    if (contentSize <= 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 && 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();

}

}

导入android.content.Context；
导入android.graphics.Matrix；
导入android.graphics.PointF；
导入android.graphics.drawable.drawable；
导入android.util.AttributeSet；
导入android.util.Log；
导入android.view.MotionEvent；
导入android.view.scalegestruedetector；
导入android.view.view；
导入android.widget.ImageView；
公共类TouchImageView扩展了ImageView{
矩阵；
//我们可能处于这三种状态之一
静态最终int NONE=0；
静态最终整数阻力=1；
静态最终整数缩放=2；
int模式=无；
//记住一些关于缩放的事情
PointF last=新的PointF（）；
PointF start=新的PointF（）；
浮动最小刻度=1f；
浮点最大刻度=3f；
浮动[]m；
int viewWidth，viewHeight；
静态最终int CLICK=3；
浮动存储比例=1f；
受保护的浮子起始宽度、起始高度；
int oldMeasuredWidth，oldMeasuredHeight；
scalegestruedetector mScaleDetector；
语境；
公共TouchImageBreaked（上下文）{
超级（上下文）；
共享构造（上下文）；
}
公共TouchImageBreaked（上下文、属性集属性）{
超级（上下文，attrs）；
共享构造（上下文）；
}
私有void共享构造（上下文）{
super.setClickable（true）；
this.context=上下文；
mScaleDetector=新的scalegestruedetector（上下文，新的ScaleListener（））；
矩阵=新矩阵（）；
m=新浮点数[9]；
setImageMatrix（矩阵）；
setScaleType（ScaleType.MATRIX）；
setOnTouchListener（新的OnTouchListener（）{
@凌驾
公共布尔onTouch（视图v，运动事件）{
mScaleDetector.onTouchEvent（事件）；
PointF curr=新的PointF（event.getX（），event.getY（））；
开关（event.getAction（））{
case MotionEvent.ACTION\u DOWN：
最后一组（当前）；
开始。设置（最后）；
模式=拖动；
打破
case MotionEvent.ACTION\u移动：
如果（模式==拖动）{
浮动deltaX=当前x-最后x；
浮动三角洲=当前y-最后y；
float fixtranx=getfixtragtrans（deltaX、viewWidth、origWidth*saveScale）；
float fixTransY=GetFixtragtrans（三角洲、视图高度、origHeight*保存比例）；
矩阵后翻译（fixtranx，fixtrany）；
fixTrans（）；
最后一组（当前x、当前y）；
}
打破
case MotionEvent.ACTION\u UP：
模式=无；
intxdiff=（int）Math.abs（curr.x-start.x）；
int yDiff=（int）Math.abs（curr.y-start.y）；
if（xDiff最大比例）{
saveScale=maxScale；
mScaleFactor=最大刻度/原始刻度；
}else if（保存比例<最小比例）{
saveScale=minScale；
mScaleFactor=最小刻度/原始刻度；
}
如果（原始宽度*保存比例