Блог

Я пишу приложение, в котором есть верхний imageview и scollview под imageview.

Imageview используется классом, предоставленным моим другом, он поддерживает масштабирование, но после того, как я нажму на изображение, затем я коснусь scollview ниже, изображение будет изменено в соответствии с размером imageview.

Мне сложно создавать свое приложение, потому что я хочу прокручивать информацию после масштабирования.

Затем я пытаюсь изменить scrollview на imageview, я обнаружил, что между двумя представлениями нет изменения размера.

Интересно, можно ли отключить функцию изменения размера для imageview для реализации моей идеи.

Приведенный ниже класс используется для imageview.

Спасибо за решения.

 import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Color;
import android.graphics.Matrix;
import android.graphics.PointF;
import android.view.MotionEvent;
import android.view.ScaleGestureDetector;
import android.view.View;
import android.widget.ImageView;

public class TouchImageView extends ImageView {

    Matrix matrix = new 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;

    float redundantXSpace, redundantYSpace;

    float width, height;
    static final int CLICK = 3;
    float saveScale = 1f;
    float right, bottom, origWidth, origHeight, bmWidth, bmHeight;
    int windowId;

    ScaleGestureDetector mScaleDetector;

    Context context;


    public TouchImageView(Context context,int id) {
        super(context);
        super.setClickable(true);
        this.context = context;
        this.windowId=id;
        mScaleDetector = new ScaleGestureDetector(context, new ScaleListener());
        setBackgroundColor(Color.BLACK);
        matrix.setTranslate(1f, 1f);
        m = new float[9];
        setImageMatrix(matrix);
        setScaleType(ScaleType.MATRIX);

        setOnTouchListener(new OnTouchListener() {

            public boolean onTouch(View v, MotionEvent event) {
                mScaleDetector.onTouchEvent(event);

                matrix.getValues(m);
                float x = m[Matrix.MTRANS_X];
                float y = m[Matrix.MTRANS_Y];
                PointF curr = new PointF(event.getX(), event.getY());

                switch (event.getAction()) {
                    case MotionEvent.ACTION_DOWN:
                        last.set(event.getX(), event.getY());
                        start.set(last);
                        mode = DRAG;
                        EasyPageActivity.resetView();

                        break;
                    case MotionEvent.ACTION_MOVE:
                        if (mode == DRAG) {
                            float deltaX = curr.x - last.x;
                            float deltaY = curr.y - last.y;
                            float scaleWidth = Math.round(origWidth * saveScale);
                            float scaleHeight = Math.round(origHeight * saveScale);
                            if (scaleWidth < width) {
                                deltaX = 0;
                                if (y   deltaY > 0)
                                    deltaY = -y;
                                else if (y   deltaY < -bottom)
                                    deltaY = -(y   bottom); 
                            } else if (scaleHeight < height) {
                                deltaY = 0;
                                if (x   deltaX > 0)
                                    deltaX = -x;
                                else if (x   deltaX < -right)
                                    deltaX = -(x   right);
                            } else {
                                if (x   deltaX > 0)
                                    deltaX = -x;
                                else if (x   deltaX < -right)
                                    deltaX = -(x   right);

                                if (y   deltaY > 0)
                                    deltaY = -y;
                                else if (y   deltaY < -bottom)
                                    deltaY = -(y   bottom);
                            }
                            matrix.postTranslate(deltaX, deltaY);
                            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 amp;amp; yDiff < CLICK)
                            performClick();
                        if(windowId==1){
                            EasyPageActivity.defineId(1);


                        }
                        if(windowId==2){
                            EasyPageActivity.defineId(2);

                        }
                        if(windowId==3){
                            EasyPageActivity.defineId(3);

                        }
                        if(windowId==4){
                            EasyPageActivity.defineId(4);

                        }
                        if(windowId==5){
                            EasyPageActivity.defineId(5);

                        }
                        if(windowId==6){
                            EasyPageActivity.defineId(6);

                        }

                        break;

                    case MotionEvent.ACTION_POINTER_UP:
                        mode = NONE;
                        break;
                }
                setImageMatrix(matrix);
                invalidate();
                return true; // indicate event was handled
            }

        });
    }

    @Override
    public void setImageBitmap(Bitmap bm) { 
        super.setImageBitmap(bm);
        bmWidth = bm.getWidth();
        bmHeight = bm.getHeight();
    }

    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 = (float)Math.min(Math.max(.301f, detector.getScaleFactor()), 4);
            float origScale = saveScale;
            saveScale *= mScaleFactor;
            if (saveScale > maxScale) {
                saveScale = maxScale;
                mScaleFactor = maxScale / origScale;
            } else if (saveScale < minScale) {
                saveScale = minScale;
                mScaleFactor = minScale / origScale;
            }
            right = width * saveScale - width - (2 * redundantXSpace * saveScale);
            bottom = height * saveScale - height - (2 * redundantYSpace * saveScale);
            if (origWidth * saveScale <= width || origHeight * saveScale <= height) {
                matrix.postScale(mScaleFactor, mScaleFactor, width / 2, height / 2);
                if (mScaleFactor < 1) {
                    matrix.getValues(m);
                    float x = m[Matrix.MTRANS_X];
                    float y = m[Matrix.MTRANS_Y];
                    if (mScaleFactor < 1) {
                        if (Math.round(origWidth * saveScale) < width) {
                            if (y < -bottom)
                                matrix.postTranslate(0, -(y   bottom));
                            else if (y > 0)
                                matrix.postTranslate(0, -y);
                        } else {
                            if (x < -right) 
                                matrix.postTranslate(-(x   right), 0);
                            else if (x > 0) 
                                matrix.postTranslate(-x, 0);
                        }
                    }
                }
            } else {
                matrix.postScale(mScaleFactor, mScaleFactor, detector.getFocusX(), detector.getFocusY());
                matrix.getValues(m);
                float x = m[Matrix.MTRANS_X];
                float y = m[Matrix.MTRANS_Y];
                if (mScaleFactor < 1) {
                    if (x < -right) 
                        matrix.postTranslate(-(x   right), 0);
                    else if (x > 0) 
                        matrix.postTranslate(-x, 0);
                    if (y < -bottom)
                        matrix.postTranslate(0, -(y   bottom));
                    else if (y > 0)
                        matrix.postTranslate(0, -y);
                }
            }
            return true;

        }
    }

    @Override
    protected void onMeasure (int widthMeasureSpec, int heightMeasureSpec)
    {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        width = MeasureSpec.getSize(widthMeasureSpec);
        height = MeasureSpec.getSize(heightMeasureSpec);
        //Fit to screen.
        float scale;
        float scaleX =  (float)width / (float)bmWidth;
        float scaleY = (float)height / (float)bmHeight;
        scale = Math.min(scaleX, scaleY);
        matrix.setScale(scale, scale);
        setImageMatrix(matrix);
        saveScale = 1f;

        // Center the image
        redundantYSpace = (float)height - (scale * (float)bmHeight) ;
        redundantXSpace = (float)width - (scale * (float)bmWidth);
        redundantYSpace /= (float)2;
        redundantXSpace /= (float)2;

        matrix.postTranslate(redundantXSpace, redundantYSpace);

        origWidth = width - 2 * redundantXSpace;
        origHeight = height - 2 * redundantYSpace;
        right = width * saveScale - width - (2 * redundantXSpace * saveScale);
        bottom = height * saveScale - height - (2 * redundantYSpace * saveScale);
        setImageMatrix(matrix);

    }
 

}

Вы нашли какое-либо решение? Если нет, то вы должны понимать, что ваше изображение изменяет свои размеры, чтобы соответствовать размеру экрана в методе onMeasure. Итак, чтобы обнаружить проблему, вы должны выполнить отладку и выяснить, почему onMeasure вызывается после изменения фокуса на ScrollView. Попробуйте поместить несколько журналов и посмотреть поток действий.