Java tutorial
/* * Copyright (C) 2012 The Android Open Source Project * * 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.raibow.yamahaspk.filtershow.imageshow; import android.animation.Animator; import android.animation.ValueAnimator; import android.content.Context; import android.content.res.Resources; import android.graphics.Bitmap; import android.graphics.BitmapFactory; import android.graphics.BitmapShader; import android.graphics.Canvas; import android.graphics.Color; import android.graphics.Matrix; import android.graphics.Paint; import android.graphics.Point; import android.graphics.Rect; import android.graphics.RectF; import android.graphics.Shader; import android.graphics.drawable.NinePatchDrawable; import android.support.v4.widget.EdgeEffectCompat; import android.util.AttributeSet; import android.util.Log; import android.view.GestureDetector; import android.view.GestureDetector.OnDoubleTapListener; import android.view.GestureDetector.OnGestureListener; import android.view.MotionEvent; import android.view.ScaleGestureDetector; import android.view.View; import android.widget.LinearLayout; import com.raibow.yamahaspk.R; import com.raibow.yamahaspk.filtershow.FilterShowActivity; import com.raibow.yamahaspk.filtershow.filters.FilterMirrorRepresentation; import com.raibow.yamahaspk.filtershow.filters.FilterRepresentation; import com.raibow.yamahaspk.filtershow.filters.ImageFilter; import com.raibow.yamahaspk.filtershow.pipeline.ImagePreset; import com.raibow.yamahaspk.filtershow.tools.SaveImage; import java.io.File; import java.util.ArrayList; public class ImageShow extends View implements OnGestureListener, ScaleGestureDetector.OnScaleGestureListener, OnDoubleTapListener { private static final String LOGTAG = "ImageShow"; private static final boolean ENABLE_ZOOMED_COMPARISON = false; protected Paint mPaint = new Paint(); protected int mTextSize; protected int mTextPadding; protected int mBackgroundColor; private GestureDetector mGestureDetector = null; private ScaleGestureDetector mScaleGestureDetector = null; protected Rect mImageBounds = new Rect(); private boolean mOriginalDisabled = false; private boolean mTouchShowOriginal = false; private long mTouchShowOriginalDate = 0; private final long mTouchShowOriginalDelayMin = 200; // 200ms private int mShowOriginalDirection = 0; private static int UNVEIL_HORIZONTAL = 1; private static int UNVEIL_VERTICAL = 2; private NinePatchDrawable mShadow = null; private Rect mShadowBounds = new Rect(); private int mShadowMargin = 15; // not scaled, fixed in the asset private boolean mShadowDrawn = false; private Point mTouchDown = new Point(); private Point mTouch = new Point(); private boolean mFinishedScalingOperation = false; private int mOriginalTextMargin; private int mOriginalTextSize; private String mOriginalText; private boolean mZoomIn = false; Point mOriginalTranslation = new Point(); float mOriginalScale; float mStartFocusX, mStartFocusY; private EdgeEffectCompat mEdgeEffect = null; private static final int EDGE_LEFT = 1; private static final int EDGE_TOP = 2; private static final int EDGE_RIGHT = 3; private static final int EDGE_BOTTOM = 4; private int mCurrentEdgeEffect = 0; private int mEdgeSize = 100; private static final int mAnimationSnapDelay = 200; private static final int mAnimationZoomDelay = 400; private ValueAnimator mAnimatorScale = null; private ValueAnimator mAnimatorTranslateX = null; private ValueAnimator mAnimatorTranslateY = null; private enum InteractionMode { NONE, SCALE, MOVE } InteractionMode mInteractionMode = InteractionMode.NONE; private static Bitmap sMask; private Paint mMaskPaint = new Paint(); private Matrix mShaderMatrix = new Matrix(); private boolean mDidStartAnimation = false; private static Bitmap convertToAlphaMask(Bitmap b) { Bitmap a = Bitmap.createBitmap(b.getWidth(), b.getHeight(), Bitmap.Config.ALPHA_8); Canvas c = new Canvas(a); c.drawBitmap(b, 0.0f, 0.0f, null); return a; } private static Shader createShader(Bitmap b) { return new BitmapShader(b, Shader.TileMode.CLAMP, Shader.TileMode.CLAMP); } private FilterShowActivity mActivity = null; public FilterShowActivity getActivity() { return mActivity; } public boolean hasModifications() { return MasterImage.getImage().hasModifications(); } public void resetParameter() { // TODO: implement reset } public void onNewValue(int parameter) { invalidate(); } public ImageShow(Context context, AttributeSet attrs, int defStyle) { super(context, attrs, defStyle); setupImageShow(context); } public ImageShow(Context context, AttributeSet attrs) { super(context, attrs); setupImageShow(context); } public ImageShow(Context context) { super(context); setupImageShow(context); } private void setupImageShow(Context context) { Resources res = context.getResources(); mTextSize = res.getDimensionPixelSize(R.dimen.photoeditor_text_size); mTextPadding = res.getDimensionPixelSize(R.dimen.photoeditor_text_padding); mOriginalTextMargin = res.getDimensionPixelSize(R.dimen.photoeditor_original_text_margin); mOriginalTextSize = res.getDimensionPixelSize(R.dimen.photoeditor_original_text_size); mBackgroundColor = res.getColor(R.color.background_screen); mOriginalText = res.getString(R.string.original_picture_text); mShadow = (NinePatchDrawable) res.getDrawable(R.drawable.geometry_shadow); setupGestureDetector(context); mActivity = (FilterShowActivity) context; if (sMask == null) { Bitmap mask = BitmapFactory.decodeResource(res, R.drawable.spot_mask); sMask = convertToAlphaMask(mask); } mEdgeEffect = new EdgeEffectCompat(context); mEdgeSize = res.getDimensionPixelSize(R.dimen.edge_glow_size); } public void attach() { MasterImage.getImage().addObserver(this); bindAsImageLoadListener(); MasterImage.getImage().resetGeometryImages(false); } public void detach() { MasterImage.getImage().removeObserver(this); mMaskPaint.reset(); } public void setupGestureDetector(Context context) { mGestureDetector = new GestureDetector(context, this); mScaleGestureDetector = new ScaleGestureDetector(context, this); } @Override protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { int parentWidth = MeasureSpec.getSize(widthMeasureSpec); int parentHeight = MeasureSpec.getSize(heightMeasureSpec); setMeasuredDimension(parentWidth, parentHeight); } public ImageFilter getCurrentFilter() { return MasterImage.getImage().getCurrentFilter(); } /* consider moving the following 2 methods into a subclass */ /** * This function calculates a Image to Screen Transformation matrix * * @param reflectRotation set true if you want the rotation encoded * @return Image to Screen transformation matrix */ protected Matrix getImageToScreenMatrix(boolean reflectRotation) { MasterImage master = MasterImage.getImage(); if (master.getOriginalBounds() == null) { return new Matrix(); } Matrix m = GeometryMathUtils.getImageToScreenMatrix(master.getPreset().getGeometryFilters(), reflectRotation, master.getOriginalBounds(), getWidth(), getHeight()); Point translate = master.getTranslation(); float scaleFactor = master.getScaleFactor(); m.postTranslate(translate.x, translate.y); m.postScale(scaleFactor, scaleFactor, getWidth() / 2.0f, getHeight() / 2.0f); return m; } /** * This function calculates a to Screen Image Transformation matrix * * @param reflectRotation set true if you want the rotation encoded * @return Screen to Image transformation matrix */ protected Matrix getScreenToImageMatrix(boolean reflectRotation) { Matrix m = getImageToScreenMatrix(reflectRotation); Matrix invert = new Matrix(); m.invert(invert); return invert; } public ImagePreset getImagePreset() { return MasterImage.getImage().getPreset(); } @Override public void onDraw(Canvas canvas) { mPaint.reset(); mPaint.setAntiAlias(true); mPaint.setFilterBitmap(true); MasterImage.getImage().setImageShowSize(getWidth() - 2 * mShadowMargin, getHeight() - 2 * mShadowMargin); MasterImage img = MasterImage.getImage(); // Hide the loading indicator as needed if (mActivity.isLoadingVisible() && getFilteredImage() != null) { if ((img.getLoadedPreset() == null) || (img.getLoadedPreset() != null && img.getLoadedPreset().equals(img.getCurrentPreset()))) { mActivity.stopLoadingIndicator(); } else if (img.getLoadedPreset() != null) { return; } mActivity.stopLoadingIndicator(); } canvas.save(); mShadowDrawn = false; Bitmap highresPreview = MasterImage.getImage().getHighresImage(); Bitmap fullHighres = MasterImage.getImage().getPartialImage(); boolean isDoingNewLookAnimation = MasterImage.getImage().onGoingNewLookAnimation(); if (highresPreview == null || isDoingNewLookAnimation) { drawImageAndAnimate(canvas, getFilteredImage()); } else { drawImageAndAnimate(canvas, highresPreview); } drawHighresImage(canvas, fullHighres); drawCompareImage(canvas, getGeometryOnlyImage()); canvas.restore(); if (!mEdgeEffect.isFinished()) { canvas.save(); float dx = (getHeight() - getWidth()) / 2f; if (getWidth() > getHeight()) { dx = -(getWidth() - getHeight()) / 2f; } if (mCurrentEdgeEffect == EDGE_BOTTOM) { canvas.rotate(180, getWidth() / 2, getHeight() / 2); } else if (mCurrentEdgeEffect == EDGE_RIGHT) { canvas.rotate(90, getWidth() / 2, getHeight() / 2); canvas.translate(0, dx); } else if (mCurrentEdgeEffect == EDGE_LEFT) { canvas.rotate(270, getWidth() / 2, getHeight() / 2); canvas.translate(0, dx); } if (mCurrentEdgeEffect != 0) { mEdgeEffect.draw(canvas); } canvas.restore(); invalidate(); } else { mCurrentEdgeEffect = 0; } } private void drawHighresImage(Canvas canvas, Bitmap fullHighres) { Matrix originalToScreen = MasterImage.getImage().originalImageToScreen(); if (fullHighres != null && originalToScreen != null) { Matrix screenToOriginal = new Matrix(); originalToScreen.invert(screenToOriginal); Rect rBounds = new Rect(); rBounds.set(MasterImage.getImage().getPartialBounds()); if (fullHighres != null) { originalToScreen.preTranslate(rBounds.left, rBounds.top); canvas.clipRect(mImageBounds); canvas.drawBitmap(fullHighres, originalToScreen, mPaint); } } } public void resetImageCaches(ImageShow caller) { MasterImage.getImage().invalidatePreview(); } public Bitmap getFiltersOnlyImage() { return MasterImage.getImage().getFiltersOnlyImage(); } public Bitmap getGeometryOnlyImage() { return MasterImage.getImage().getGeometryOnlyImage(); } public Bitmap getFilteredImage() { return MasterImage.getImage().getFilteredImage(); } public void drawImageAndAnimate(Canvas canvas, Bitmap image) { if (image == null) { return; } MasterImage master = MasterImage.getImage(); Matrix m = master.computeImageToScreen(image, 0, false); if (m == null) { return; } canvas.save(); RectF d = new RectF(0, 0, image.getWidth(), image.getHeight()); m.mapRect(d); d.roundOut(mImageBounds); boolean showAnimatedImage = master.onGoingNewLookAnimation(); if (!showAnimatedImage && mDidStartAnimation) { // animation ended, but do we have the correct image to show? if (master.getPreset().equals(master.getCurrentPreset())) { // we do, let's stop showing the animated image mDidStartAnimation = false; MasterImage.getImage().resetAnimBitmap(); } else { showAnimatedImage = true; } } else if (showAnimatedImage) { mDidStartAnimation = true; } if (showAnimatedImage) { canvas.save(); // Animation uses the image before the change Bitmap previousImage = master.getPreviousImage(); Matrix mp = master.computeImageToScreen(previousImage, 0, false); RectF dp = new RectF(0, 0, previousImage.getWidth(), previousImage.getHeight()); mp.mapRect(dp); Rect previousBounds = new Rect(); dp.roundOut(previousBounds); float centerX = dp.centerX(); float centerY = dp.centerY(); boolean needsToDrawImage = true; if (master.getCurrentLookAnimation() == MasterImage.CIRCLE_ANIMATION) { float maskScale = MasterImage.getImage().getMaskScale(); if (maskScale >= 0.0f) { float maskW = sMask.getWidth() / 2.0f; float maskH = sMask.getHeight() / 2.0f; Point point = mActivity.hintTouchPoint(this); float maxMaskScale = 2 * Math.max(getWidth(), getHeight()) / Math.min(maskW, maskH); maskScale = maskScale * maxMaskScale; float x = point.x - maskW * maskScale; float y = point.y - maskH * maskScale; // Prepare the shader mShaderMatrix.reset(); mShaderMatrix.setScale(1.0f / maskScale, 1.0f / maskScale); mShaderMatrix.preTranslate(-x + mImageBounds.left, -y + mImageBounds.top); float scaleImageX = mImageBounds.width() / (float) image.getWidth(); float scaleImageY = mImageBounds.height() / (float) image.getHeight(); mShaderMatrix.preScale(scaleImageX, scaleImageY); mMaskPaint.reset(); mMaskPaint.setShader(createShader(image)); mMaskPaint.getShader().setLocalMatrix(mShaderMatrix); drawShadow(canvas, mImageBounds); // as needed canvas.drawBitmap(previousImage, m, mPaint); canvas.clipRect(mImageBounds); canvas.translate(x, y); canvas.scale(maskScale, maskScale); canvas.drawBitmap(sMask, 0, 0, mMaskPaint); needsToDrawImage = false; } } else if (master.getCurrentLookAnimation() == MasterImage.ROTATE_ANIMATION) { Rect d1 = computeImageBounds(master.getPreviousImage().getHeight(), master.getPreviousImage().getWidth()); Rect d2 = computeImageBounds(master.getPreviousImage().getWidth(), master.getPreviousImage().getHeight()); float finalScale = d1.width() / (float) d2.height(); finalScale = (1.0f * (1.0f - master.getAnimFraction())) + (finalScale * master.getAnimFraction()); canvas.rotate(master.getAnimRotationValue(), centerX, centerY); canvas.scale(finalScale, finalScale, centerX, centerY); } else if (master.getCurrentLookAnimation() == MasterImage.MIRROR_ANIMATION) { if (master.getCurrentFilterRepresentation() instanceof FilterMirrorRepresentation) { FilterMirrorRepresentation rep = (FilterMirrorRepresentation) master .getCurrentFilterRepresentation(); ImagePreset preset = master.getPreset(); ArrayList<FilterRepresentation> geometry = (ArrayList<FilterRepresentation>) preset .getGeometryFilters(); GeometryMathUtils.GeometryHolder holder = null; holder = GeometryMathUtils.unpackGeometry(geometry); if (holder.rotation.value() == 90 || holder.rotation.value() == 270) { if (rep.isHorizontal() && !rep.isVertical()) { canvas.scale(1, master.getAnimRotationValue(), centerX, centerY); } else if (rep.isVertical() && !rep.isHorizontal()) { canvas.scale(1, master.getAnimRotationValue(), centerX, centerY); } else if (rep.isHorizontal() && rep.isVertical()) { canvas.scale(master.getAnimRotationValue(), 1, centerX, centerY); } else { canvas.scale(master.getAnimRotationValue(), 1, centerX, centerY); } } else { if (rep.isHorizontal() && !rep.isVertical()) { canvas.scale(master.getAnimRotationValue(), 1, centerX, centerY); } else if (rep.isVertical() && !rep.isHorizontal()) { canvas.scale(master.getAnimRotationValue(), 1, centerX, centerY); } else if (rep.isHorizontal() && rep.isVertical()) { canvas.scale(1, master.getAnimRotationValue(), centerX, centerY); } else { canvas.scale(1, master.getAnimRotationValue(), centerX, centerY); } } } } if (needsToDrawImage) { drawShadow(canvas, previousBounds); // as needed canvas.drawBitmap(previousImage, mp, mPaint); } canvas.restore(); } else { drawShadow(canvas, mImageBounds); // as needed canvas.drawBitmap(image, m, mPaint); } canvas.restore(); } private Rect computeImageBounds(int imageWidth, int imageHeight) { float scale = GeometryMathUtils.scale(imageWidth, imageHeight, getWidth(), getHeight()); float w = imageWidth * scale; float h = imageHeight * scale; float ty = (getHeight() - h) / 2.0f; float tx = (getWidth() - w) / 2.0f; return new Rect((int) tx + mShadowMargin, (int) ty + mShadowMargin, (int) (w + tx) - mShadowMargin, (int) (h + ty) - mShadowMargin); } private void drawShadow(Canvas canvas, Rect d) { if (!mShadowDrawn) { mShadowBounds.set(d.left - mShadowMargin, d.top - mShadowMargin, d.right + mShadowMargin, d.bottom + mShadowMargin); mShadow.setBounds(mShadowBounds); mShadow.draw(canvas); mShadowDrawn = true; } } public void drawCompareImage(Canvas canvas, Bitmap image) { MasterImage master = MasterImage.getImage(); boolean showsOriginal = master.showsOriginal(); if (!showsOriginal && !mTouchShowOriginal) return; canvas.save(); if (image != null) { if (mShowOriginalDirection == 0) { if (Math.abs(mTouch.y - mTouchDown.y) > Math.abs(mTouch.x - mTouchDown.x)) { mShowOriginalDirection = UNVEIL_VERTICAL; } else { mShowOriginalDirection = UNVEIL_HORIZONTAL; } } int px = 0; int py = 0; if (mShowOriginalDirection == UNVEIL_VERTICAL) { px = mImageBounds.width(); py = mTouch.y - mImageBounds.top; } else { px = mTouch.x - mImageBounds.left; py = mImageBounds.height(); if (showsOriginal) { px = mImageBounds.width(); } } Rect d = new Rect(mImageBounds.left, mImageBounds.top, mImageBounds.left + px, mImageBounds.top + py); if (mShowOriginalDirection == UNVEIL_HORIZONTAL) { if (mTouchDown.x - mTouch.x > 0) { d.set(mImageBounds.left + px, mImageBounds.top, mImageBounds.right, mImageBounds.top + py); } } else { if (mTouchDown.y - mTouch.y > 0) { d.set(mImageBounds.left, mImageBounds.top + py, mImageBounds.left + px, mImageBounds.bottom); } } canvas.clipRect(d); Matrix m = master.computeImageToScreen(image, 0, false); canvas.drawBitmap(image, m, mPaint); Paint paint = new Paint(); paint.setColor(Color.BLACK); paint.setStrokeWidth(3); if (mShowOriginalDirection == UNVEIL_VERTICAL) { canvas.drawLine(mImageBounds.left, mTouch.y, mImageBounds.right, mTouch.y, paint); } else { canvas.drawLine(mTouch.x, mImageBounds.top, mTouch.x, mImageBounds.bottom, paint); } Rect bounds = new Rect(); paint.setAntiAlias(true); paint.setTextSize(mOriginalTextSize); paint.getTextBounds(mOriginalText, 0, mOriginalText.length(), bounds); paint.setColor(Color.BLACK); paint.setStyle(Paint.Style.STROKE); paint.setStrokeWidth(3); canvas.drawText(mOriginalText, mImageBounds.left + mOriginalTextMargin, mImageBounds.top + bounds.height() + mOriginalTextMargin, paint); paint.setStyle(Paint.Style.FILL); paint.setStrokeWidth(1); paint.setColor(Color.WHITE); canvas.drawText(mOriginalText, mImageBounds.left + mOriginalTextMargin, mImageBounds.top + bounds.height() + mOriginalTextMargin, paint); } canvas.restore(); } public void bindAsImageLoadListener() { MasterImage.getImage().addListener(this); } public void updateImage() { invalidate(); } public void imageLoaded() { updateImage(); } public void saveImage(FilterShowActivity filterShowActivity, File file) { SaveImage.saveImage(getImagePreset(), filterShowActivity, file); } public boolean scaleInProgress() { return mScaleGestureDetector.isInProgress(); } @Override public boolean onTouchEvent(MotionEvent event) { super.onTouchEvent(event); int action = event.getAction(); action = action & MotionEvent.ACTION_MASK; mGestureDetector.onTouchEvent(event); boolean scaleInProgress = scaleInProgress(); mScaleGestureDetector.onTouchEvent(event); if (mInteractionMode == InteractionMode.SCALE) { return true; } if (!scaleInProgress() && scaleInProgress) { // If we were scaling, the scale will stop but we will // still issue an ACTION_UP. Let the subclasses know. mFinishedScalingOperation = true; } int ex = (int) event.getX(); int ey = (int) event.getY(); if (action == MotionEvent.ACTION_DOWN) { mInteractionMode = InteractionMode.MOVE; mTouchDown.x = ex; mTouchDown.y = ey; mTouchShowOriginalDate = System.currentTimeMillis(); mShowOriginalDirection = 0; MasterImage.getImage().setOriginalTranslation(MasterImage.getImage().getTranslation()); } if (action == MotionEvent.ACTION_MOVE && mInteractionMode == InteractionMode.MOVE) { mTouch.x = ex; mTouch.y = ey; float scaleFactor = MasterImage.getImage().getScaleFactor(); if (scaleFactor > 1 && (!ENABLE_ZOOMED_COMPARISON || event.getPointerCount() == 2)) { float translateX = (mTouch.x - mTouchDown.x) / scaleFactor; float translateY = (mTouch.y - mTouchDown.y) / scaleFactor; Point originalTranslation = MasterImage.getImage().getOriginalTranslation(); Point translation = MasterImage.getImage().getTranslation(); translation.x = (int) (originalTranslation.x + translateX); translation.y = (int) (originalTranslation.y + translateY); MasterImage.getImage().setTranslation(translation); mTouchShowOriginal = false; } else if (enableComparison() && !mOriginalDisabled && (System.currentTimeMillis() - mTouchShowOriginalDate > mTouchShowOriginalDelayMin) && event.getPointerCount() == 1) { mTouchShowOriginal = true; } } if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL || action == MotionEvent.ACTION_OUTSIDE) { mInteractionMode = InteractionMode.NONE; mTouchShowOriginal = false; mTouchDown.x = 0; mTouchDown.y = 0; mTouch.x = 0; mTouch.y = 0; if (MasterImage.getImage().getScaleFactor() <= 1) { MasterImage.getImage().setScaleFactor(1); MasterImage.getImage().resetTranslation(); } } float scaleFactor = MasterImage.getImage().getScaleFactor(); Point translation = MasterImage.getImage().getTranslation(); constrainTranslation(translation, scaleFactor); MasterImage.getImage().setTranslation(translation); invalidate(); return true; } private void startAnimTranslation(int fromX, int toX, int fromY, int toY, int delay) { if (fromX == toX && fromY == toY) { return; } if (mAnimatorTranslateX != null) { mAnimatorTranslateX.cancel(); } if (mAnimatorTranslateY != null) { mAnimatorTranslateY.cancel(); } mAnimatorTranslateX = ValueAnimator.ofInt(fromX, toX); mAnimatorTranslateY = ValueAnimator.ofInt(fromY, toY); mAnimatorTranslateX.setDuration(delay); mAnimatorTranslateY.setDuration(delay); mAnimatorTranslateX.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() { @Override public void onAnimationUpdate(ValueAnimator animation) { Point translation = MasterImage.getImage().getTranslation(); translation.x = (Integer) animation.getAnimatedValue(); MasterImage.getImage().setTranslation(translation); invalidate(); } }); mAnimatorTranslateY.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() { @Override public void onAnimationUpdate(ValueAnimator animation) { Point translation = MasterImage.getImage().getTranslation(); translation.y = (Integer) animation.getAnimatedValue(); MasterImage.getImage().setTranslation(translation); invalidate(); } }); mAnimatorTranslateX.start(); mAnimatorTranslateY.start(); } private void applyTranslationConstraints() { float scaleFactor = MasterImage.getImage().getScaleFactor(); Point translation = MasterImage.getImage().getTranslation(); int x = translation.x; int y = translation.y; constrainTranslation(translation, scaleFactor); if (x != translation.x || y != translation.y) { startAnimTranslation(x, translation.x, y, translation.y, mAnimationSnapDelay); } } protected boolean enableComparison() { return true; } @Override public boolean onDoubleTap(MotionEvent arg0) { mZoomIn = !mZoomIn; float scale = 1.0f; final float x = arg0.getX(); final float y = arg0.getY(); if (mZoomIn) { scale = MasterImage.getImage().getMaxScaleFactor(); } if (scale != MasterImage.getImage().getScaleFactor()) { if (mAnimatorScale != null) { mAnimatorScale.cancel(); } mAnimatorScale = ValueAnimator.ofFloat(MasterImage.getImage().getScaleFactor(), scale); float translateX = (getWidth() / 2 - x); float translateY = (getHeight() / 2 - y); Point translation = MasterImage.getImage().getTranslation(); int startTranslateX = translation.x; int startTranslateY = translation.y; if (scale != 1.0f) { translation.x = (int) (mOriginalTranslation.x + translateX); translation.y = (int) (mOriginalTranslation.y + translateY); } else { translation.x = 0; translation.y = 0; } constrainTranslation(translation, scale); startAnimTranslation(startTranslateX, translation.x, startTranslateY, translation.y, mAnimationZoomDelay); mAnimatorScale.setDuration(mAnimationZoomDelay); mAnimatorScale.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() { @Override public void onAnimationUpdate(ValueAnimator animation) { MasterImage.getImage().setScaleFactor((Float) animation.getAnimatedValue()); invalidate(); } }); mAnimatorScale.addListener(new Animator.AnimatorListener() { @Override public void onAnimationStart(Animator animation) { } @Override public void onAnimationEnd(Animator animation) { applyTranslationConstraints(); MasterImage.getImage().needsUpdatePartialPreview(); invalidate(); } @Override public void onAnimationCancel(Animator animation) { } @Override public void onAnimationRepeat(Animator animation) { } }); mAnimatorScale.start(); } return true; } private void constrainTranslation(Point translation, float scale) { int currentEdgeEffect = 0; if (scale <= 1) { mCurrentEdgeEffect = 0; mEdgeEffect.finish(); return; } Matrix originalToScreen = MasterImage.getImage().originalImageToScreen(); Rect originalBounds = MasterImage.getImage().getOriginalBounds(); RectF screenPos = new RectF(originalBounds); originalToScreen.mapRect(screenPos); boolean rightConstraint = screenPos.right < getWidth() - mShadowMargin; boolean leftConstraint = screenPos.left > mShadowMargin; boolean topConstraint = screenPos.top > mShadowMargin; boolean bottomConstraint = screenPos.bottom < getHeight() - mShadowMargin; if (screenPos.width() > getWidth()) { if (rightConstraint && !leftConstraint) { float tx = screenPos.right - translation.x * scale; translation.x = (int) ((getWidth() - mShadowMargin - tx) / scale); currentEdgeEffect = EDGE_RIGHT; } else if (leftConstraint && !rightConstraint) { float tx = screenPos.left - translation.x * scale; translation.x = (int) ((mShadowMargin - tx) / scale); currentEdgeEffect = EDGE_LEFT; } } else { float tx = screenPos.right - translation.x * scale; float dx = (getWidth() - 2 * mShadowMargin - screenPos.width()) / 2f; translation.x = (int) ((getWidth() - mShadowMargin - tx - dx) / scale); } if (screenPos.height() > getHeight()) { if (bottomConstraint && !topConstraint) { float ty = screenPos.bottom - translation.y * scale; translation.y = (int) ((getHeight() - mShadowMargin - ty) / scale); currentEdgeEffect = EDGE_BOTTOM; } else if (topConstraint && !bottomConstraint) { float ty = screenPos.top - translation.y * scale; translation.y = (int) ((mShadowMargin - ty) / scale); currentEdgeEffect = EDGE_TOP; } } else { float ty = screenPos.bottom - translation.y * scale; float dy = (getHeight() - 2 * mShadowMargin - screenPos.height()) / 2f; translation.y = (int) ((getHeight() - mShadowMargin - ty - dy) / scale); } if (mCurrentEdgeEffect != currentEdgeEffect) { if (mCurrentEdgeEffect == 0 || currentEdgeEffect != 0) { mCurrentEdgeEffect = currentEdgeEffect; mEdgeEffect.finish(); } mEdgeEffect.setSize(getWidth(), mEdgeSize); } if (currentEdgeEffect != 0) { mEdgeEffect.onPull(mEdgeSize); } } @Override public boolean onDoubleTapEvent(MotionEvent arg0) { return false; } @Override public boolean onSingleTapConfirmed(MotionEvent arg0) { return false; } @Override public boolean onDown(MotionEvent arg0) { return false; } @Override public boolean onFling(MotionEvent startEvent, MotionEvent endEvent, float arg2, float arg3) { if (mActivity == null) { return false; } if (endEvent.getPointerCount() == 2) { return false; } return true; } @Override public void onLongPress(MotionEvent arg0) { } @Override public boolean onScroll(MotionEvent arg0, MotionEvent arg1, float arg2, float arg3) { return false; } @Override public void onShowPress(MotionEvent arg0) { } @Override public boolean onSingleTapUp(MotionEvent arg0) { return false; } public boolean useUtilityPanel() { return false; } public void openUtilityPanel(final LinearLayout accessoryViewList) { } @Override public boolean onScale(ScaleGestureDetector detector) { MasterImage img = MasterImage.getImage(); float scaleFactor = img.getScaleFactor(); scaleFactor = scaleFactor * detector.getScaleFactor(); if (scaleFactor > MasterImage.getImage().getMaxScaleFactor()) { scaleFactor = MasterImage.getImage().getMaxScaleFactor(); } if (scaleFactor < 1.0f) { scaleFactor = 1.0f; } MasterImage.getImage().setScaleFactor(scaleFactor); scaleFactor = img.getScaleFactor(); float focusx = detector.getFocusX(); float focusy = detector.getFocusY(); float translateX = (focusx - mStartFocusX) / scaleFactor; float translateY = (focusy - mStartFocusY) / scaleFactor; Point translation = MasterImage.getImage().getTranslation(); translation.x = (int) (mOriginalTranslation.x + translateX); translation.y = (int) (mOriginalTranslation.y + translateY); MasterImage.getImage().setTranslation(translation); invalidate(); return true; } @Override public boolean onScaleBegin(ScaleGestureDetector detector) { Point pos = MasterImage.getImage().getTranslation(); mOriginalTranslation.x = pos.x; mOriginalTranslation.y = pos.y; mOriginalScale = MasterImage.getImage().getScaleFactor(); mStartFocusX = detector.getFocusX(); mStartFocusY = detector.getFocusY(); mInteractionMode = InteractionMode.SCALE; return true; } @Override public void onScaleEnd(ScaleGestureDetector detector) { mInteractionMode = InteractionMode.NONE; if (MasterImage.getImage().getScaleFactor() < 1) { MasterImage.getImage().setScaleFactor(1); invalidate(); } } public boolean didFinishScalingOperation() { if (mFinishedScalingOperation) { mFinishedScalingOperation = false; return true; } return false; } }