双指旋转（以图片中心为旋转中心）

View

package com.hfengxiang.example.myphotoview;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.PointF;
import android.graphics.RectF;
import android.util.AttributeSet;
import android.util.Log;
import android.view.MotionEvent;
import android.view.View;

import androidx.annotation.Nullable;

public class TestCanvasView extends View implements RotateProcessor.OnRotateListener {

    private Paint paint;
    private Bitmap bitmap;
    private int rotation = 0;
    private float currentScale = 1f;
    private RectF rectF;
    private RotateProcessor rotateProcessor;
    private boolean isRecover;
    private PointF translate = new PointF();

    public TestCanvasView setTranslate(float x,float y) {
        translate.set(x,y);
        return this;
    }

    public TestCanvasView(Context context) {
        this(context, null);
    }

    public TestCanvasView(Context context, @Nullable AttributeSet attrs) {
        this(context, attrs, -1);
    }

    public TestCanvasView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init(context);
    }

    private void init(Context context) {
        paint = new Paint();
        paint.setAntiAlias(true);
        bitmap = Utils.getPhoto(getResources(), getResources().getDisplayMetrics().widthPixels);
        rectF = new RectF();
        rotateProcessor = new RotateProcessor();
        rotateProcessor.setRotateListener(this);
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        canvas.save();
//        canvas.translate(rotateProcessor.getRotateCenter().x-getWidth() / 2f,rotateProcessor.getRotateCenter().y-getHeight() / 2f);
        canvas.translate(translate.x,translate.y);
        canvas.translate(getWidth() / 2f, getHeight() / 2f);
//        canvas.rotate(rotation,rotateProcessor.getRotateCenter().x-getWidth() / 2f,rotateProcessor.getRotateCenter().y-getHeight() / 2f);
        canvas.rotate(rotation);
        rectF.set(-currentWidth()/2f,-currentHeight()/2f,
                currentWidth()/2f,currentHeight()/2f);
        canvas.drawBitmap(bitmap,null, rectF, paint);
        paint.setColor(Color.GREEN);
        canvas.drawCircle(0,0,15, paint);
        canvas.restore();
        paint.setColor(Color.RED);
        canvas.drawCircle(0,0,15, paint);
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        switch (event.getActionMasked()) {
            case MotionEvent.ACTION_DOWN:
            case MotionEvent.ACTION_POINTER_DOWN:
                rotateProcessor.handleActionDown(event);
                break;
            case MotionEvent.ACTION_MOVE:
                rotateProcessor.handleActionMove(event);
                break;
            case MotionEvent.ACTION_UP:
            case MotionEvent.ACTION_POINTER_UP:
                rotateProcessor.handleActionUp(event);
                break;
        }
        return true;
    }

    private float currentWidth(){
        return bitmap.getWidth()* currentScale;
    }
    private float currentHeight(){
        return bitmap.getHeight()* currentScale;
    }

    @Override
    public void onRotate(float changeDegree, float totalDegree, float scale) {
        rotation = (int) totalDegree;
        Log.i("rotation","rotation="+rotation);
        if(scale!=-1){
            currentScale = scale;
//            Log.i("Scale","scale="+scale);
//            setTranslate(0,0);
//            setTranslate((rotateProcessor.getRotateCenter().x-getWidth() / 2f)*scale,(rotateProcessor.getRotateCenter().y-getHeight() / 2f)*scale);
        }else {
            setTranslate(0,0);
            Log.i("PADDING","rectF.left="+rectF.left);
            Log.i("PADDING","rectF.top="+rectF.top);
            Log.i("PADDING","rectF.right="+rectF.right);
            Log.i("PADDING","rectF.bottom="+rectF.bottom);
        }
        invalidate();
    }

    @Override
    public float[] onCalculateScale(float targetDegree) {
        targetDegree = computeTargetDegree(targetDegree);
        Log.i("onCalculateScale","targetScale="+targetDegree);
        float targetScale = ScaleCalculator.calculateScale(getWidth(), getHeight(), bitmap.getWidth(), bitmap.getHeight(),
                (int) targetDegree);
        isRecover = true;
        return new float[]{currentScale,targetScale};
    }

    @Override
    public void onRecoverEnd() {
        isRecover = false;
    }

    /**
     * 根据旋转的角度计算出图片复位应当到达的角度