Código de implementação para a realização de zoom e arrastar da imagem usando o controle ImageView personalizado do Android

Resumo: Através de controle personalizado de ImageView, chama o componente personalizado no xml layout para realizar o escalonamento de imagens.

/**
* Controle de ImageView personalizado, permite a escalonamento e arrasto de多点to de imagens
* 
* @author qiuwanyong
*/
public class MyImageView extends ImageView {
/**
* Constante de estado de inicialização
*/
public static final int STATUS_INIT = 1;
/**
* Constante de estado de ampliação de imagem
*/
public static final int STATUS_ZOOM_OUT = 2;
/**
* Constante de estado de redução de imagem
*/
public static final int STATUS_ZOOM_IN = 3;
/**
* Constante de estado de arrasto de imagem
*/
public static final int STATUS_MOVE = 4;
/**
* Matriz usada para realizar transformações de movimentação e escalonamento de imagens
*/
private Matrix matrix = new Matrix();
/**
* o objeto Bitmap a ser exibido
*/
private Bitmap sourceBitmap;
/**
* Grava o estado da operação atual, os valores opcionais são STATUS_INIT, STATUS_ZOOM_OUT, STATUS_ZOOM_IN e STATUS_MOVE
*/
private int currentStatus;
/**
* Largura do controle ZoomImageView.
*/
private int width;
/**
* Altura do controle ZoomImageView.
*/
private int height;
/**
* Grava o valor da coordenada horizontal do ponto central quando os dois dedos estão na tela.
*/
private float centerPointX;
/**
* Grava o valor da coordenada vertical do ponto central quando os dois dedos estão na tela.
*/
private float centerPointY;
/**
* Grava a largura atual da imagem, este valor mudará quando a imagem for zoomada.
*/
private float currentBitmapWidth;
/**
* Grava a altura atual da imagem, este valor mudará quando a imagem for zoomada.
*/
private float currentBitmapHeight;
/**
* Grava a coordenada horizontal da última vez que o dedo se moveu.
*/
private float lastXMove = -1;
/**
* Grava a coordenada vertical da última vez que o dedo se moveu.
*/
private float lastYMove = -1;
/**
* Grava a distância de movimento do dedo na direção horizontal.
*/
private float movedDistanceX;
/**
* Grava a distância de movimento do dedo na direção vertical.
*/
private float movedDistanceY;
/**
* Grava o valor de deslocamento horizontal da imagem na matriz.
*/
private float totalTranslateX;
/**
* Grava o valor de deslocamento vertical da imagem na matriz.
*/
private float totalTranslateY;
/**
* Grava a proporção total de zoom da imagem na matriz.
*/
private float totalRatio;
/**
* Grava a proporção de zoom causada pelo movimento dos dedos.
*/
private float scaledRatio;
/**
* Grava a proporção de zoom inicial da imagem.
*/
private float initRatio;
/**
* Grava a distância entre os dois dedos na última vez.
*/
private double lastFingerDis;
/**
* Construtor do ZoomImageView, define o estado de operação atual como STATUS_INIT.
* 
* @param context
* @param attrs
*/
public MyImageView(Context context, AttributeSet attrs) {
super(context, attrs);
currentStatus = STATUS_INIT;
}
/**
* Define a imagem a ser exibida.
* 
* @param bitmap
* o objeto Bitmap a ser exibido
*/
public void setImageBitmap(Bitmap bitmap) {
sourceBitmap = bitmap;
invalidate();
}
@Override
protected void onLayout(boolean changed, int left, int top, int right,
int bottom) {
super.onLayout(changed, left, top, right, bottom);
if (changed) {
// obter respectivamente a largura e a altura do ZoomImageView
width = getWidth();
height = getHeight();
}
}
@SuppressLint("NewApi") @Override
public boolean onTouchEvent(MotionEvent event) {
if (initRatio == totalRatio) {
getParent().requestDisallowInterceptTouchEvent(false);
} else {
getParent().requestDisallowInterceptTouchEvent(true);
}
switch (event.getActionMasked()) {
case MotionEvent.ACTION_POINTER_DOWN:
if (event.getPointerCount() == 2) {
// quando houver dois dedos pressionados na tela, calcular a distância entre os dedos
lastFingerDis = distanceBetweenFingers(event);
}
break;
case MotionEvent.ACTION_CANCEL:
case MotionEvent.ACTION_MOVE:
if (event.getPointerCount() == 1) {
// somente quando um dedo estiver pressionado e movendo na tela, o estado é de arrasto
float xMove = event.getX();
float yMove = event.getY();
if (lastXMove == -1 && lastYMove == -1) {
lastXMove = xMove;
lastYMove = yMove;
}
currentStatus = STATUS_MOVE;
movedDistanceX = xMove - lastXMove;
movedDistanceY = yMove - lastYMove;
// realizar verificação de limite, não permitindo que a imagem seja arrastada para fora dos limites
if (totalTranslateX + movedDistanceX > 0) {}}
movedDistanceX = 0;
} else if (width - (totalTranslateX + movedDistanceX) > currentBitmapWidth) {
movedDistanceX = 0;
}
if (totalTranslateY + movedDistanceY > 0) {
movedDistanceY = 0;
} else if (height - (totalTranslateY + movedDistanceY) > currentBitmapHeight) {
movedDistanceY = 0;
}
// Chama o método onDraw() para desenhar a imagem
invalidate();
lastXMove = xMove;
lastYMove = yMove;
} else if (event.getPointerCount() == 2) {
// Quando dois dedos estão pressionando e movendo na tela, é um estado de zoom
centerPointBetweenFingers(event);
double fingerDis = distanceBetweenFingers(event);
if (fingerDis > lastFingerDis) {
currentStatus = STATUS_ZOOM_OUT;
} else {
currentStatus = STATUS_ZOOM_IN;
}
// Realizar verificação de multiplicador de zoom, permitindo apenas ampliar a imagem4vezes, a menor que pode ser reduzida é a proporção inicial
if ((currentStatus == STATUS_ZOOM_OUT && totalRatio < 4 * initRatio)
|| (currentStatus == STATUS_ZOOM_IN && totalRatio > initRatio)) {
scaledRatio = (float) (fingerDis / lastFingerDis);
totalRatio = totalRatio * scaledRatio;
if (totalRatio > 4 * initRatio) {
totalRatio = 4 * initRatio;
} else if (totalRatio < initRatio) {
totalRatio = initRatio;
}
// Chama o método onDraw() para desenhar a imagem
invalidate();
lastFingerDis = fingerDis;
}
}
break;
case MotionEvent.ACTION_POINTER_UP:
if (event.getPointerCount() == 2) {
// Restaurar o valor temporário ao toque do dedo na tela
lastXMove = -1;
lastYMove = -1;
}
break;
case MotionEvent.ACTION_UP:
// Restaurar o valor temporário ao toque do dedo na tela
lastXMove = -1;
lastYMove = -1;
break;
default:
break;
}
return true;
}
/**
* Decidir o tipo de operação de desenho da imagem com base no valor de currentStatus.
*/
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
switch (currentStatus) {
case STATUS_ZOOM_OUT:
case STATUS_ZOOM_IN:
zoom(canvas);
break;
case STATUS_MOVE:
move(canvas);
break;
case STATUS_INIT:
initBitmap(canvas);
default:
if (sourceBitmap != null) {
canvas.drawBitmap(sourceBitmap, matrix, null);
}
break;
}
}
/**
* Realizar processamento de ampliação da imagem.
* 
* @param canvas
*/
private void zoom(Canvas canvas) {
matrix.reset();
// Aumentar a imagem com base na taxa de ampliação total
matrix.postScale(totalRatio, totalRatio);
float scaledWidth = sourceBitmap.getWidth() * totalRatio;
float scaledHeight = sourceBitmap.getHeight() * totalRatio;
float translateX = 0f;
float translateY = 0f;
// Se a largura da imagem atual for menor que a largura da tela, então a ampliação horizontal é feita com base no eixo horizontal do centro da tela. Caso contrário, a ampliação horizontal é feita com base no eixo horizontal do ponto central dos dois dedos.
if (currentBitmapWidth < width) {
translateX = (width - scaledWidth) / 2f;
} else {
translateX = totalTranslateX * scaledRatio + centerPointX
* (1 - scaledRatio);
// Realizar verificação de limites para garantir que a imagem, após a ampliação, não saia da tela na direção horizontal
if (translateX > 0) {
translateX = 0;
} else if (width - translateX > scaledWidth) {
translateX = width - scaledWidth;
}
}
// Se a altura da imagem atual for menor que a altura da tela, então a ampliação vertical é feita com base no eixo vertical do centro da tela. Caso contrário, a ampliação vertical é feita com base no eixo vertical do ponto central dos dois dedos.
if (currentBitmapHeight < height) {}}
translateY = (height - scaledHeight) / 2f;
} else {
translateY = totalTranslateY * scaledRatio + centerPointY
* (1 - scaledRatio);
// Realizar verificação de limites para garantir que a imagem não saia da tela na direção vertical após a ampliação
if (translateY > 0) {
translateY = 0;
} else if (height - translateY > scaledHeight) {
translateY = height - scaledHeight;
}
}
// Deslocar a imagem após a ampliação para garantir que o ponto central não mude após a ampliação
matrix.postTranslate(translateX, translateY);
totalTranslateX = translateX;
totalTranslateY = translateY;
currentBitmapWidth = scaledWidth;
currentBitmapHeight = scaledHeight;
canvas.drawBitmap(sourceBitmap, matrix, null);
}
/**
* Tratar a translação da imagem
* 
* @param canvas
*/
private void move(Canvas canvas) {
matrix.reset();
// Calcular o valor de deslocamento total com base na distância de deslocamento do dedo
float translateX = totalTranslateX + movedDistanceX;
float translateY = totalTranslateY + movedDistanceY;
// Ajustar a imagem com a proporção de ampliação existente
matrix.postScale(totalRatio, totalRatio);
// Mover de acordo com a distância de deslocamento
matrix.postTranslate(translateX, translateY);
totalTranslateX = translateX;
totalTranslateY = translateY;
canvas.drawBitmap(sourceBitmap, matrix, null);
}
/**
* Iniciar as operações de inicialização da imagem, incluindo centralizar a imagem e comprimir a imagem quando a imagem for maior que a largura e altura da tela.
* 
* @param canvas
*/
private void initBitmap(Canvas canvas) {
if (sourceBitmap != null) {
matrix.reset();
int bitmapWidth = sourceBitmap.getWidth();
int bitmapHeight = sourceBitmap.getHeight();
if (bitmapWidth > width || bitmapHeight > height) {
if (bitmapWidth - width > bitmapHeight - height) {}}
// Quando a largura da imagem é maior que a largura da tela, comprime a imagem proporcionalmente para que ela possa ser mostrada completamente
float ratio = width / (bitmapWidth * 1.0f);
matrix.postScale(ratio, ratio);
float translateY = (height - (bitmapHeight * ratio)) / 2f;
// Desloca-se na direção do eixo y para garantir que a imagem seja mostrada no centro
matrix.postTranslate(0, translateY);
totalTranslateY = translateY;
totalRatio = initRatio = ratio;
} else {
// Quando a altura da imagem é maior que a altura da tela, comprime a imagem proporcionalmente para que ela possa ser mostrada completamente
float ratio = height / (bitmapHeight * 1.0f);
matrix.postScale(ratio, ratio);
float translateX = (width - (bitmapWidth * ratio)) / 2f;
// Desloca-se na direção do eixo x para garantir que a imagem seja mostrada no centro
matrix.postTranslate(translateX, 0);
totalTranslateX = translateX;
totalRatio = initRatio = ratio;
}
currentBitmapWidth = bitmapWidth * initRatio;
currentBitmapHeight = bitmapHeight * initRatio;
} else {
// Quando a largura e a altura da imagem são menores que a largura e a altura da tela, mostre a imagem no centro diretamente
float translateX = (width - sourceBitmap.getWidth()) / 2f;
float translateY = (height - sourceBitmap.getHeight()) / 2f;
matrix.postTranslate(translateX, translateY);
totalTranslateX = translateX;
totalTranslateY = translateY;
totalRatio = initRatio = 1f;
currentBitmapWidth = bitmapWidth;
currentBitmapHeight = bitmapHeight;
}
canvas.drawBitmap(sourceBitmap, matrix, null);
}
}
/**
* Calcula a distância entre os dois dedos.
* 
* Calcular as coordenadas do ponto central entre os dois dedos.
* @return A distância entre os dois dedos
*/
@SuppressLint("NewApi") private double distanceBetweenFingers(MotionEvent event) {
float disX = Math.abs(event.getX(0) - event.getX(1event.getY(
event.getX( - float disY = Math.abs(event.getY(0)1event.getY(
)); * return Math.sqrt(disX + disX * disY
}
/**
* disY);
* 
* Calcular as coordenadas do ponto central entre os dois dedos.
*/
@param event
@SuppressLint("NewApi") private void centerPointBetweenFingers(MotionEvent event) {
float xPoint0 = event.getX(0);
float yPoint0 = event.getY(0);1 float xPoint1);
float yPoint1 = event.getY(1);
centerPointX = (xPoint0 + xPoint1) / 2;
centerPointY = (yPoint0 + yPoint1) / 2;
}
}

Chamada de layout

O código de implementação da ampliação e arrasto de imagens do Android através do controle de ImageView personalizado, apresentado acima pelo editor, espero que ajude a todos. Se tiver alguma dúvida, por favor, deixe um comentário, o editor responderá o mais rápido possível. Agradecemos também o apoio ao site Tutorial de Grito!

Declaração: O conteúdo deste artigo é extraído da internet, pertence ao respectivo proprietário, fornecido voluntariamente pelos usuários da internet e carregado automaticamente. Este site não possui direitos autorais, não foi editado manualmente e não assume nenhuma responsabilidade legal. Se você encontrar conteúdo suspeito de violação de direitos autorais, por favor, envie um e-mail para: notice#oldtoolbag.com (ao enviar e-mail, substitua # por @ para denunciar, e forneça provas relevantes. Caso seja confirmada, o site deletará imediatamente o conteúdo suspeito de violação de direitos autorais.)