1：listView item 增加間距 以及item根部局 margin 失效的解決方法：在加一層布局蚁飒，作為根布局 設(shè)置padding ,或者 新增根布局的下一次布局設(shè)置margin涧狮。
參考文章：https://blog.csdn.net/android_freshman/article/details/52077323
2：fragmentTransaction.commitAllowingStateLoss()方法可以防止出現(xiàn)java.lang.IllegalStateException: Can not perform this action after onSaveInstanceState
3：gradle文件夾誤刪后户誓，然后再撤銷刪除取具，雖然里面的gradle-wrapper.jar包和gradle-wrapper.properties都恢復(fù)了价认，但是會錯(cuò)誤: 找不到或無法加載主類 org.gradle.wrapper.GradleWrapperMain缤底，然后打開我的電腦查看項(xiàng)目下的gradle文件夾下的gradle-wrapper.jar的大小是0B顾患，這時(shí)只需要將正常工程下的gradle-wrapper.jar考過來就行了。
4：設(shè)置圖片點(diǎn)擊之后可以放大个唧，拖動(dòng)描验，用glide加載圖片的話，gif圖也能放大坑鱼，而且還可以加載超長圖膘流，代碼如下：
public class PhotoView extends ImageView {
private final static int MIN_ROTATE = 35;
private final static int ANIMA_DURING = 340;
private final static float MAX_SCALE = 2.5f;
private int mMinRotate;
private int mAnimaDuring;
private float mMaxScale;
private int MAX_OVER_SCROLL = 0;
private int MAX_FLING_OVER_SCROLL = 0;
private int MAX_OVER_RESISTANCE = 0;
private int MAX_ANIM_FROM_WAITE = 500;
private Matrix mBaseMatrix = new Matrix();
private Matrix mAnimaMatrix = new Matrix();
private Matrix mSynthesisMatrix = new Matrix();
private Matrix mTmpMatrix = new Matrix();
private RotateGestureDetector mRotateDetector;
private GestureDetector mDetector;
private ScaleGestureDetector mScaleDetector;
private OnClickListener mClickListener;
private ScaleType mScaleType;
private boolean hasMultiTouch;
private boolean hasDrawable;
private boolean isKnowSize;
private boolean hasOverTranslate;
private boolean isEnable = false;
private boolean isRotateEnable = false;
private boolean isInit;
private boolean mAdjustViewBounds;
// 當(dāng)前是否處于放大狀態(tài)
private boolean isZoonUp;
private boolean canRotate;
private boolean imgLargeWidth;
private boolean imgLargeHeight;
private float mRotateFlag;
private float mDegrees;
private float mScale = 1.0f;
private int mTranslateX;
private int mTranslateY;
private float mHalfBaseRectWidth;
private float mHalfBaseRectHeight;
private RectF mWidgetRect = new RectF();
private RectF mBaseRect = new RectF();
private RectF mImgRect = new RectF();
private RectF mTmpRect = new RectF();
private RectF mCommonRect = new RectF();
private PointF mScreenCenter = new PointF();
private PointF mScaleCenter = new PointF();
private PointF mRotateCenter = new PointF();
private Transform mTranslate = new Transform();
private RectF mClip;
private Info mFromInfo;
private long mInfoTime;
private Runnable mCompleteCallBack;
private OnLongClickListener mLongClick;
public PhotoView(Context context) {
super(context);
init();
}
public PhotoView(Context context, AttributeSet attrs) {
super(context, attrs);
init();
}
public PhotoView(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
init();
}
private void init() {
super.setScaleType(ScaleType.MATRIX);
if (mScaleType == null) mScaleType = ScaleType.CENTER_INSIDE;
mRotateDetector = new RotateGestureDetector(mRotateListener);
mDetector = new GestureDetector(getContext(), mGestureListener);
mScaleDetector = new ScaleGestureDetector(getContext(), mScaleListener);
float density = getResources().getDisplayMetrics().density;
MAX_OVER_SCROLL = (int) (density * 30);
MAX_FLING_OVER_SCROLL = (int) (density * 30);
MAX_OVER_RESISTANCE = (int) (density * 140);
mMinRotate = MIN_ROTATE;
mAnimaDuring = ANIMA_DURING;
mMaxScale = MAX_SCALE;
}
/**
* 獲取默認(rèn)的動(dòng)畫持續(xù)時(shí)間
*/
public int getDefaultAnimaDuring() {
return ANIMA_DURING;
}
@Override
public void setOnClickListener(OnClickListener l) {
super.setOnClickListener(l);
mClickListener = l;
}
@Override
public void setScaleType(ScaleType scaleType) {
if (scaleType == ScaleType.MATRIX) return;
if (scaleType != mScaleType) {
mScaleType = scaleType;
if (isInit) {
initBase();
}
}
}
@Override
public void setOnLongClickListener(OnLongClickListener l) {
mLongClick = l;
}
/**
* 設(shè)置動(dòng)畫的插入器
*/
public void setInterpolator(Interpolator interpolator) {
mTranslate.setInterpolator(interpolator);
}
/**
* 獲取動(dòng)畫持續(xù)時(shí)間
*/
public int getAnimaDuring() {
return mAnimaDuring;
}
/**
* 設(shè)置動(dòng)畫的持續(xù)時(shí)間
*/
public void setAnimaDuring(int during) {
mAnimaDuring = during;
}
/**
* 設(shè)置最大可以縮放的倍數(shù)
*/
public void setMaxScale(float maxScale) {
mMaxScale = maxScale;
}
/**
* 獲取最大可以縮放的倍數(shù)
*/
public float getMaxScale() {
return mMaxScale;
}
/**
* 啟用縮放功能
*/
public void enable() {
isEnable = true;
}
/**
* 禁用縮放功能
*/
public void disenable() {
isEnable = false;
}
/**
* 啟用旋轉(zhuǎn)功能
*/
public void enableRotate() {
isRotateEnable = true;
}
/**
* 禁用旋轉(zhuǎn)功能
*/
public void disableRotate() {
isRotateEnable = false;
}
/**
*/
public void setMaxAnimFromWaiteTime(int wait) {
MAX_ANIM_FROM_WAITE = wait;
}
@Override
public void setImageResource(int resId) {
Drawable drawable = null;
try {
drawable = getResources().getDrawable(resId);
} catch (Exception e) {
}
setImageDrawable(drawable);
}
@Override
public void setImageDrawable(Drawable drawable) {
super.setImageDrawable(drawable);
if (drawable == null) {
hasDrawable = false;
return;
}
if (!hasSize(drawable))
return;
if (!hasDrawable) {
hasDrawable = true;
}
initBase();
}
private boolean hasSize(Drawable d) {
if ((d.getIntrinsicHeight() <= 0 || d.getIntrinsicWidth() <= 0)
&& (d.getMinimumWidth() <= 0 || d.getMinimumHeight() <= 0)
&& (d.getBounds().width() <= 0 || d.getBounds().height() <= 0)) {
return false;
}
return true;
}
private static int getDrawableWidth(Drawable d) {
int width = d.getIntrinsicWidth();
if (width <= 0) width = d.getMinimumWidth();
if (width <= 0) width = d.getBounds().width();
return width;
}
private static int getDrawableHeight(Drawable d) {
int height = d.getIntrinsicHeight();
if (height <= 0) height = d.getMinimumHeight();
if (height <= 0) height = d.getBounds().height();
return height;
}
private void initBase() {
if (!hasDrawable) return;
if (!isKnowSize) return;
mBaseMatrix.reset();
mAnimaMatrix.reset();
isZoonUp = false;
Drawable img = getDrawable();
int w = getWidth();
int h = getHeight();
int imgw = getDrawableWidth(img);
int imgh = getDrawableHeight(img);
mBaseRect.set(0, 0, imgw, imgh);
// 以圖片中心點(diǎn)居中位移
int tx = (w - imgw) / 2;
int ty = (h - imgh) / 2;
float sx = 1;
float sy = 1;
// 縮放，默認(rèn)不超過屏幕大小
if (imgw > w) {
sx = (float) w / imgw;
}
if (imgh > h) {
sy = (float) h / imgh;
}
float scale = sx < sy ? sx : sy;
mBaseMatrix.reset();
mBaseMatrix.postTranslate(tx, ty);
mBaseMatrix.postScale(scale, scale, mScreenCenter.x, mScreenCenter.y);
mBaseMatrix.mapRect(mBaseRect);
mHalfBaseRectWidth = mBaseRect.width() / 2;
mHalfBaseRectHeight = mBaseRect.height() / 2;
mScaleCenter.set(mScreenCenter);
mRotateCenter.set(mScaleCenter);
executeTranslate();
switch (mScaleType) {
case CENTER:
initCenter();
break;
case CENTER_CROP:
initCenterCrop();
break;
case CENTER_INSIDE:
initCenterInside();
break;
case FIT_CENTER:
initFitCenter();
break;
case FIT_START:
initFitStart();
break;
case FIT_END:
initFitEnd();
break;
case FIT_XY:
initFitXY();
break;
}
isInit = true;
if (mFromInfo != null && System.currentTimeMillis() - mInfoTime < MAX_ANIM_FROM_WAITE) {
animaFrom(mFromInfo);
}
mFromInfo = null;
}
private void initCenter() {
if (!hasDrawable) return;
if (!isKnowSize) return;
Drawable img = getDrawable();
int imgw = getDrawableWidth(img);
int imgh = getDrawableHeight(img);
if (imgw > mWidgetRect.width() || imgh > mWidgetRect.height()) {
float scaleX = imgw / mImgRect.width();
float scaleY = imgh / mImgRect.height();
mScale = scaleX > scaleY ? scaleX : scaleY;
mAnimaMatrix.postScale(mScale, mScale, mScreenCenter.x, mScreenCenter.y);
executeTranslate();
resetBase();
}
}
private void initCenterCrop() {
if (mImgRect.width() < mWidgetRect.width() || mImgRect.height() < mWidgetRect.height()) {
float scaleX = mWidgetRect.width() / mImgRect.width();
float scaleY = mWidgetRect.height() / mImgRect.height();
mScale = scaleX > scaleY ? scaleX : scaleY;
mAnimaMatrix.postScale(mScale, mScale, mScreenCenter.x, mScreenCenter.y);
executeTranslate();
resetBase();
}
}
private void initCenterInside() {
if (mImgRect.width() > mWidgetRect.width() || mImgRect.height() > mWidgetRect.height()) {
float scaleX = mWidgetRect.width() / mImgRect.width();
float scaleY = mWidgetRect.height() / mImgRect.height();
mScale = scaleX < scaleY ? scaleX : scaleY;
mAnimaMatrix.postScale(mScale, mScale, mScreenCenter.x, mScreenCenter.y);
executeTranslate();
resetBase();
}
}
private void initFitCenter() {
if (mImgRect.width() < mWidgetRect.width()) {
mScale = mWidgetRect.width() / mImgRect.width();
mAnimaMatrix.postScale(mScale, mScale, mScreenCenter.x, mScreenCenter.y);
executeTranslate();
resetBase();
}
}
private void initFitStart() {
initFitCenter();
float ty = -mImgRect.top;
mAnimaMatrix.postTranslate(0, ty);
executeTranslate();
resetBase();
mTranslateY += ty;
}
private void initFitEnd() {
initFitCenter();
float ty = (mWidgetRect.bottom - mImgRect.bottom);
mTranslateY += ty;
mAnimaMatrix.postTranslate(0, ty);
executeTranslate();
resetBase();
}
private void initFitXY() {
float scaleX = mWidgetRect.width() / mImgRect.width();
float scaleY = mWidgetRect.height() / mImgRect.height();
mAnimaMatrix.postScale(scaleX, scaleY, mScreenCenter.x, mScreenCenter.y);
executeTranslate();
resetBase();
}
private void resetBase() {
Drawable img = getDrawable();
int imgw = getDrawableWidth(img);
int imgh = getDrawableHeight(img);
mBaseRect.set(0, 0, imgw, imgh);
mBaseMatrix.set(mSynthesisMatrix);
mBaseMatrix.mapRect(mBaseRect);
mHalfBaseRectWidth = mBaseRect.width() / 2;
mHalfBaseRectHeight = mBaseRect.height() / 2;
mScale = 1;
mTranslateX = 0;
mTranslateY = 0;
mAnimaMatrix.reset();
}
private void executeTranslate() {
mSynthesisMatrix.set(mBaseMatrix);
mSynthesisMatrix.postConcat(mAnimaMatrix);
setImageMatrix(mSynthesisMatrix);
mAnimaMatrix.mapRect(mImgRect, mBaseRect);
imgLargeWidth = mImgRect.width() > mWidgetRect.width();
imgLargeHeight = mImgRect.height() > mWidgetRect.height();
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
if (!hasDrawable) {
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
return;
}
Drawable d = getDrawable();
int drawableW = getDrawableWidth(d);
int drawableH = getDrawableHeight(d);
int pWidth = MeasureSpec.getSize(widthMeasureSpec);
int pHeight = MeasureSpec.getSize(heightMeasureSpec);
int widthMode = MeasureSpec.getMode(widthMeasureSpec);
int heightMode = MeasureSpec.getMode(heightMeasureSpec);
int width = 0;
int height = 0;
ViewGroup.LayoutParams p = getLayoutParams();
if (p == null) {
p = new ViewGroup.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT);
}
if (p.width == ViewGroup.LayoutParams.MATCH_PARENT) {
if (widthMode == MeasureSpec.UNSPECIFIED) {
width = drawableW;
} else {
width = pWidth;
}
} else {
if (widthMode == MeasureSpec.EXACTLY) {
width = pWidth;
} else if (widthMode == MeasureSpec.AT_MOST) {
width = drawableW > pWidth ? pWidth : drawableW;
} else {
width = drawableW;
}
}
if (p.height == ViewGroup.LayoutParams.MATCH_PARENT) {
if (heightMode == MeasureSpec.UNSPECIFIED) {
height = drawableH;
} else {
height = pHeight;
}
} else {
if (heightMode == MeasureSpec.EXACTLY) {
height = pHeight;
} else if (heightMode == MeasureSpec.AT_MOST) {
height = drawableH > pHeight ? pHeight : drawableH;
} else {
height = drawableH;
}
}
if (mAdjustViewBounds && (float) drawableW / drawableH != (float) width / height) {
float hScale = (float) height / drawableH;
float wScale = (float) width / drawableW;
float scale = hScale < wScale ? hScale : wScale;
width = p.width == ViewGroup.LayoutParams.MATCH_PARENT ? width : (int) (drawableW * scale);
height = p.height == ViewGroup.LayoutParams.MATCH_PARENT ? height : (int) (drawableH * scale);
}
setMeasuredDimension(width, height);
}
@Override
public void setAdjustViewBounds(boolean adjustViewBounds) {
super.setAdjustViewBounds(adjustViewBounds);
mAdjustViewBounds = adjustViewBounds;
}
@Override
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
super.onSizeChanged(w, h, oldw, oldh);
mWidgetRect.set(0, 0, w, h);
mScreenCenter.set(w / 2, h / 2);
if (!isKnowSize) {
isKnowSize = true;
initBase();
}
}
@Override
public void draw(Canvas canvas) {
if (mClip != null) {
canvas.clipRect(mClip);
mClip = null;
}
super.draw(canvas);
}
@Override
public boolean dispatchTouchEvent(MotionEvent event) {
if (isEnable) {
final int Action = event.getActionMasked();
if (event.getPointerCount() >= 2) hasMultiTouch = true;
mDetector.onTouchEvent(event);
if (isRotateEnable) {
mRotateDetector.onTouchEvent(event);
}
mScaleDetector.onTouchEvent(event);
if (Action == MotionEvent.ACTION_UP || Action == MotionEvent.ACTION_CANCEL) onUp();
return true;
} else {
return super.dispatchTouchEvent(event);
}
}
private void onUp() {
if (mTranslate.isRuning) return;
if (canRotate || mDegrees % 90 != 0) {
float toDegrees = (int) (mDegrees / 90) * 90;
float remainder = mDegrees % 90;
if (remainder > 45)
toDegrees += 90;
else if (remainder < -45)
toDegrees -= 90;
mTranslate.withRotate((int) mDegrees, (int) toDegrees);
mDegrees = toDegrees;
}
float scale = mScale;
if (mScale < 1) {
scale = 1;
mTranslate.withScale(mScale, 1);
} else if (mScale > mMaxScale) {
scale = mMaxScale;
mTranslate.withScale(mScale, mMaxScale);
}
float cx = mImgRect.left + mImgRect.width() / 2;
float cy = mImgRect.top + mImgRect.height() / 2;
mScaleCenter.set(cx, cy);
mRotateCenter.set(cx, cy);
mTranslateX = 0;
mTranslateY = 0;
mTmpMatrix.reset();
mTmpMatrix.postTranslate(-mBaseRect.left, -mBaseRect.top);
mTmpMatrix.postTranslate(cx - mHalfBaseRectWidth, cy - mHalfBaseRectHeight);
mTmpMatrix.postScale(scale, scale, cx, cy);
mTmpMatrix.postRotate(mDegrees, cx, cy);
mTmpMatrix.mapRect(mTmpRect, mBaseRect);
doTranslateReset(mTmpRect);
mTranslate.start();
}
private void doTranslateReset(RectF imgRect) {
int tx = 0;
int ty = 0;
if (imgRect.width() <= mWidgetRect.width()) {
if (!isImageCenterWidth(imgRect))
tx = -(int) ((mWidgetRect.width() - imgRect.width()) / 2 - imgRect.left);
} else {
if (imgRect.left > mWidgetRect.left) {
tx = (int) (imgRect.left - mWidgetRect.left);
} else if (imgRect.right < mWidgetRect.right) {
tx = (int) (imgRect.right - mWidgetRect.right);
}
}
if (imgRect.height() <= mWidgetRect.height()) {
if (!isImageCenterHeight(imgRect))
ty = -(int) ((mWidgetRect.height() - imgRect.height()) / 2 - imgRect.top);
} else {
if (imgRect.top > mWidgetRect.top) {
ty = (int) (imgRect.top - mWidgetRect.top);
} else if (imgRect.bottom < mWidgetRect.bottom) {
ty = (int) (imgRect.bottom - mWidgetRect.bottom);
}
}
if (tx != 0 || ty != 0) {
if (!mTranslate.mFlingScroller.isFinished()) mTranslate.mFlingScroller.abortAnimation();
mTranslate.withTranslate(mTranslateX, mTranslateY, -tx, -ty);
}
}
private boolean isImageCenterHeight(RectF rect) {
return Math.abs(Math.round(rect.top) - (mWidgetRect.height() - rect.height()) / 2) < 1;
}
private boolean isImageCenterWidth(RectF rect) {
return Math.abs(Math.round(rect.left) - (mWidgetRect.width() - rect.width()) / 2) < 1;
}
private OnRotateListener mRotateListener = new OnRotateListener() {
@Override
public void onRotate(float degrees, float focusX, float focusY) {
mRotateFlag += degrees;
if (canRotate) {
mDegrees += degrees;
mAnimaMatrix.postRotate(degrees, focusX, focusY);
} else {
if (Math.abs(mRotateFlag) >= mMinRotate) {
canRotate = true;
mRotateFlag = 0;
}
}
}
};
private ScaleGestureDetector.OnScaleGestureListener mScaleListener = new ScaleGestureDetector.OnScaleGestureListener() {
@Override
public boolean onScale(ScaleGestureDetector detector) {
float scaleFactor = detector.getScaleFactor();
if (Float.isNaN(scaleFactor) || Float.isInfinite(scaleFactor))
return false;
mScale *= scaleFactor;
// mScaleCenter.set(detector.getFocusX(), detector.getFocusY());
mAnimaMatrix.postScale(scaleFactor, scaleFactor, detector.getFocusX(), detector.getFocusY());
executeTranslate();
return true;
}
public boolean onScaleBegin(ScaleGestureDetector detector) {
return true;
}
public void onScaleEnd(ScaleGestureDetector detector) {
}
};
private float resistanceScrollByX(float overScroll, float detalX) {
float s = detalX * (Math.abs(Math.abs(overScroll) - MAX_OVER_RESISTANCE) / (float) MAX_OVER_RESISTANCE);
return s;
}
private float resistanceScrollByY(float overScroll, float detalY) {
float s = detalY * (Math.abs(Math.abs(overScroll) - MAX_OVER_RESISTANCE) / (float) MAX_OVER_RESISTANCE);
return s;
}
/**
* 匹配兩個(gè)Rect的共同部分輸出到out鲁沥，若無共同部分則輸出0呼股，0，0画恰，0
*/
private void mapRect(RectF r1, RectF r2, RectF out) {
float l, r, t, b;
l = r1.left > r2.left ? r1.left : r2.left;
r = r1.right < r2.right ? r1.right : r2.right;
if (l > r) {
out.set(0, 0, 0, 0);
return;
}
t = r1.top > r2.top ? r1.top : r2.top;
b = r1.bottom < r2.bottom ? r1.bottom : r2.bottom;
if (t > b) {
out.set(0, 0, 0, 0);
return;
}
out.set(l, t, r, b);
}
private void checkRect() {
if (!hasOverTranslate) {
mapRect(mWidgetRect, mImgRect, mCommonRect);
}
}
private Runnable mClickRunnable = new Runnable() {
@Override
public void run() {
if (mClickListener != null) {
mClickListener.onClick(PhotoView.this);
}
}
};
private GestureDetector.OnGestureListener mGestureListener = new GestureDetector.SimpleOnGestureListener() {
@Override
public void onLongPress(MotionEvent e) {
if (mLongClick != null) {
mLongClick.onLongClick(PhotoView.this);
}
}
@Override
public boolean onDown(MotionEvent e) {
hasOverTranslate = false;
hasMultiTouch = false;
canRotate = false;
removeCallbacks(mClickRunnable);
return false;
}
@Override
public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
if (hasMultiTouch) return false;
if (!imgLargeWidth && !imgLargeHeight) return false;
if (mTranslate.isRuning) return false;
float vx = velocityX;
float vy = velocityY;
if (Math.round(mImgRect.left) >= mWidgetRect.left || Math.round(mImgRect.right) <= mWidgetRect.right) {
vx = 0;
}
if (Math.round(mImgRect.top) >= mWidgetRect.top || Math.round(mImgRect.bottom) <= mWidgetRect.bottom) {
vy = 0;
}
if (canRotate || mDegrees % 90 != 0) {
float toDegrees = (int) (mDegrees / 90) * 90;
float remainder = mDegrees % 90;
if (remainder > 45)
toDegrees += 90;
else if (remainder < -45)
toDegrees -= 90;
mTranslate.withRotate((int) mDegrees, (int) toDegrees);
mDegrees = toDegrees;
}
doTranslateReset(mImgRect);
mTranslate.withFling(vx, vy);
mTranslate.start();
// onUp(e2);
return super.onFling(e1, e2, velocityX, velocityY);
}
@Override
public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
if (mTranslate.isRuning) {
mTranslate.stop();
}
if (canScrollHorizontallySelf(distanceX)) {
if (distanceX < 0 && mImgRect.left - distanceX > mWidgetRect.left)
distanceX = mImgRect.left;
if (distanceX > 0 && mImgRect.right - distanceX < mWidgetRect.right)
distanceX = mImgRect.right - mWidgetRect.right;
mAnimaMatrix.postTranslate(-distanceX, 0);
mTranslateX -= distanceX;
} else if (imgLargeWidth || hasMultiTouch || hasOverTranslate) {
checkRect();
if (!hasMultiTouch) {
if (distanceX < 0 && mImgRect.left - distanceX > mCommonRect.left)
distanceX = resistanceScrollByX(mImgRect.left - mCommonRect.left, distanceX);
if (distanceX > 0 && mImgRect.right - distanceX < mCommonRect.right)
distanceX = resistanceScrollByX(mImgRect.right - mCommonRect.right, distanceX);
}
mTranslateX -= distanceX;
mAnimaMatrix.postTranslate(-distanceX, 0);
hasOverTranslate = true;
}
if (canScrollVerticallySelf(distanceY)) {
if (distanceY < 0 && mImgRect.top - distanceY > mWidgetRect.top)
distanceY = mImgRect.top;
if (distanceY > 0 && mImgRect.bottom - distanceY < mWidgetRect.bottom)
distanceY = mImgRect.bottom - mWidgetRect.bottom;
mAnimaMatrix.postTranslate(0, -distanceY);
mTranslateY -= distanceY;
} else if (imgLargeHeight || hasOverTranslate || hasMultiTouch) {
checkRect();
if (!hasMultiTouch) {
if (distanceY < 0 && mImgRect.top - distanceY > mCommonRect.top)
distanceY = resistanceScrollByY(mImgRect.top - mCommonRect.top, distanceY);
if (distanceY > 0 && mImgRect.bottom - distanceY < mCommonRect.bottom)
distanceY = resistanceScrollByY(mImgRect.bottom - mCommonRect.bottom, distanceY);
}
mAnimaMatrix.postTranslate(0, -distanceY);
mTranslateY -= distanceY;
hasOverTranslate = true;
}
executeTranslate();
return true;
}
@Override
public boolean onSingleTapUp(MotionEvent e) {
postDelayed(mClickRunnable, 250);
return false;
}
@Override
public boolean onDoubleTap(MotionEvent e) {
mTranslate.stop();
float from = 1;
float to = 1;
float imgcx = mImgRect.left + mImgRect.width() / 2;
float imgcy = mImgRect.top + mImgRect.height() / 2;
mScaleCenter.set(imgcx, imgcy);
mRotateCenter.set(imgcx, imgcy);
mTranslateX = 0;
mTranslateY = 0;
if (isZoonUp) {
from = mScale;
to = 1;
} else {
from = mScale;
to = mMaxScale;
mScaleCenter.set(e.getX(), e.getY());
}
mTmpMatrix.reset();
mTmpMatrix.postTranslate(-mBaseRect.left, -mBaseRect.top);
mTmpMatrix.postTranslate(mRotateCenter.x, mRotateCenter.y);
mTmpMatrix.postTranslate(-mHalfBaseRectWidth, -mHalfBaseRectHeight);
mTmpMatrix.postRotate(mDegrees, mRotateCenter.x, mRotateCenter.y);
mTmpMatrix.postScale(to, to, mScaleCenter.x, mScaleCenter.y);
mTmpMatrix.postTranslate(mTranslateX, mTranslateY);
mTmpMatrix.mapRect(mTmpRect, mBaseRect);
doTranslateReset(mTmpRect);
isZoonUp = !isZoonUp;
mTranslate.withScale(from, to);
mTranslate.start();
return false;
}
};
public boolean canScrollHorizontallySelf(float direction) {
if (mImgRect.width() <= mWidgetRect.width()) return false;
if (direction < 0 && Math.round(mImgRect.left) - direction >= mWidgetRect.left)
return false;
if (direction > 0 && Math.round(mImgRect.right) - direction <= mWidgetRect.right)
return false;
return true;
}
public boolean canScrollVerticallySelf(float direction) {
if (mImgRect.height() <= mWidgetRect.height()) return false;
if (direction < 0 && Math.round(mImgRect.top) - direction >= mWidgetRect.top)
return false;
if (direction > 0 && Math.round(mImgRect.bottom) - direction <= mWidgetRect.bottom)
return false;
return true;
}
@Override
public boolean canScrollHorizontally(int direction) {
if (hasMultiTouch) return true;
return canScrollHorizontallySelf(direction);
}
@Override
public boolean canScrollVertically(int direction) {
if (hasMultiTouch) return true;
return canScrollVerticallySelf(direction);
}
private class InterpolatorProxy implements Interpolator {
private Interpolator mTarget;
private InterpolatorProxy() {
mTarget = new DecelerateInterpolator();
}
public void setTargetInterpolator(Interpolator interpolator) {
mTarget = interpolator;
}
@Override
public float getInterpolation(float input) {
if (mTarget != null) {
return mTarget.getInterpolation(input);
}
return input;
}
}
private class Transform implements Runnable {
boolean isRuning;
OverScroller mTranslateScroller;
OverScroller mFlingScroller;
Scroller mScaleScroller;
Scroller mClipScroller;
Scroller mRotateScroller;
ClipCalculate C;
int mLastFlingX;
int mLastFlingY;
int mLastTranslateX;
int mLastTranslateY;
RectF mClipRect = new RectF();
InterpolatorProxy mInterpolatorProxy = new InterpolatorProxy();
Transform() {
Context ctx = getContext();
mTranslateScroller = new OverScroller(ctx, mInterpolatorProxy);
mScaleScroller = new Scroller(ctx, mInterpolatorProxy);
mFlingScroller = new OverScroller(ctx, mInterpolatorProxy);
mClipScroller = new Scroller(ctx, mInterpolatorProxy);
mRotateScroller = new Scroller(ctx, mInterpolatorProxy);
}
public void setInterpolator(Interpolator interpolator) {
mInterpolatorProxy.setTargetInterpolator(interpolator);
}
void withTranslate(int startX, int startY, int deltaX, int deltaY) {
mLastTranslateX = 0;
mLastTranslateY = 0;
mTranslateScroller.startScroll(0, 0, deltaX, deltaY, mAnimaDuring);
}
void withScale(float form, float to) {
mScaleScroller.startScroll((int) (form * 10000), 0, (int) ((to - form) * 10000), 0, mAnimaDuring);
}
void withClip(float fromX, float fromY, float deltaX, float deltaY, int d, ClipCalculate c) {
mClipScroller.startScroll((int) (fromX * 10000), (int) (fromY * 10000), (int) (deltaX * 10000), (int) (deltaY * 10000), d);
C = c;
}
void withRotate(int fromDegrees, int toDegrees) {
mRotateScroller.startScroll(fromDegrees, 0, toDegrees - fromDegrees, 0, mAnimaDuring);
}
void withRotate(int fromDegrees, int toDegrees, int during) {
mRotateScroller.startScroll(fromDegrees, 0, toDegrees - fromDegrees, 0, during);
}
void withFling(float velocityX, float velocityY) {
mLastFlingX = velocityX < 0 ? Integer.MAX_VALUE : 0;
int distanceX = (int) (velocityX > 0 ? Math.abs(mImgRect.left) : mImgRect.right - mWidgetRect.right);
distanceX = velocityX < 0 ? Integer.MAX_VALUE - distanceX : distanceX;
int minX = velocityX < 0 ? distanceX : 0;
int maxX = velocityX < 0 ? Integer.MAX_VALUE : distanceX;
int overX = velocityX < 0 ? Integer.MAX_VALUE - minX : distanceX;
mLastFlingY = velocityY < 0 ? Integer.MAX_VALUE : 0;
int distanceY = (int) (velocityY > 0 ? Math.abs(mImgRect.top) : mImgRect.bottom - mWidgetRect.bottom);
distanceY = velocityY < 0 ? Integer.MAX_VALUE - distanceY : distanceY;
int minY = velocityY < 0 ? distanceY : 0;
int maxY = velocityY < 0 ? Integer.MAX_VALUE : distanceY;
int overY = velocityY < 0 ? Integer.MAX_VALUE - minY : distanceY;
if (velocityX == 0) {
maxX = 0;
minX = 0;
}
if (velocityY == 0) {
maxY = 0;
minY = 0;
}
mFlingScroller.fling(mLastFlingX, mLastFlingY, (int) velocityX, (int) velocityY, minX, maxX, minY, maxY, Math.abs(overX) < MAX_FLING_OVER_SCROLL * 2 ? 0 : MAX_FLING_OVER_SCROLL, Math.abs(overY) < MAX_FLING_OVER_SCROLL * 2 ? 0 : MAX_FLING_OVER_SCROLL);
}
void start() {
isRuning = true;
postExecute();
}
void stop() {
removeCallbacks(this);
mTranslateScroller.abortAnimation();
mScaleScroller.abortAnimation();
mFlingScroller.abortAnimation();
mRotateScroller.abortAnimation();
isRuning = false;
}
@Override
public void run() {
// if (!isRuning) return;
boolean endAnima = true;
if (mScaleScroller.computeScrollOffset()) {
mScale = mScaleScroller.getCurrX() / 10000f;
endAnima = false;
}
if (mTranslateScroller.computeScrollOffset()) {
int tx = mTranslateScroller.getCurrX() - mLastTranslateX;
int ty = mTranslateScroller.getCurrY() - mLastTranslateY;
mTranslateX += tx;
mTranslateY += ty;
mLastTranslateX = mTranslateScroller.getCurrX();
mLastTranslateY = mTranslateScroller.getCurrY();
endAnima = false;
}
if (mFlingScroller.computeScrollOffset()) {
int x = mFlingScroller.getCurrX() - mLastFlingX;
int y = mFlingScroller.getCurrY() - mLastFlingY;
mLastFlingX = mFlingScroller.getCurrX();
mLastFlingY = mFlingScroller.getCurrY();
mTranslateX += x;
mTranslateY += y;
endAnima = false;
}
if (mRotateScroller.computeScrollOffset()) {
mDegrees = mRotateScroller.getCurrX();
endAnima = false;
}
if (mClipScroller.computeScrollOffset() || mClip != null) {
float sx = mClipScroller.getCurrX() / 10000f;
float sy = mClipScroller.getCurrY() / 10000f;
mTmpMatrix.setScale(sx, sy, (mImgRect.left + mImgRect.right) / 2, C.calculateTop());
mTmpMatrix.mapRect(mClipRect, mImgRect);
if (sx == 1) {
mClipRect.left = mWidgetRect.left;
mClipRect.right = mWidgetRect.right;
}
if (sy == 1) {
mClipRect.top = mWidgetRect.top;
mClipRect.bottom = mWidgetRect.bottom;
}
mClip = mClipRect;
}
if (!endAnima) {
applyAnima();
postExecute();
} else {
isRuning = false;
// 修復(fù)動(dòng)畫結(jié)束后邊距有些空隙彭谁，
boolean needFix = false;
if (imgLargeWidth) {
if (mImgRect.left > 0) {
mTranslateX -= mImgRect.left;
} else if (mImgRect.right < mWidgetRect.width()) {
mTranslateX -= (int) (mWidgetRect.width() - mImgRect.right);
}
needFix = true;
}
if (imgLargeHeight) {
if (mImgRect.top > 0) {
mTranslateY -= mImgRect.top;
} else if (mImgRect.bottom < mWidgetRect.height()) {
mTranslateY -= (int) (mWidgetRect.height() - mImgRect.bottom);
}
needFix = true;
}
if (needFix) {
applyAnima();
}
invalidate();
if (mCompleteCallBack != null) {
mCompleteCallBack.run();
mCompleteCallBack = null;
}
}
}
private void applyAnima() {
mAnimaMatrix.reset();
mAnimaMatrix.postTranslate(-mBaseRect.left, -mBaseRect.top);
mAnimaMatrix.postTranslate(mRotateCenter.x, mRotateCenter.y);
mAnimaMatrix.postTranslate(-mHalfBaseRectWidth, -mHalfBaseRectHeight);
mAnimaMatrix.postRotate(mDegrees, mRotateCenter.x, mRotateCenter.y);
mAnimaMatrix.postScale(mScale, mScale, mScaleCenter.x, mScaleCenter.y);
mAnimaMatrix.postTranslate(mTranslateX, mTranslateY);
executeTranslate();
}
private void postExecute() {
if (isRuning) post(this);
}
}
public Info getInfo() {
RectF rect = new RectF();
int[] p = new int[2];
getLocation(this, p);
rect.set(p[0] + mImgRect.left, p[1] + mImgRect.top, p[0] + mImgRect.right, p[1] + mImgRect.bottom);
return new Info(rect, mImgRect, mWidgetRect, mBaseRect, mScreenCenter, mScale, mDegrees, mScaleType);
}
public static Info getImageViewInfo(ImageView imgView) {
int[] p = new int[2];
getLocation(imgView, p);
Drawable drawable = imgView.getDrawable();
Matrix matrix = imgView.getImageMatrix();
int width = getDrawableWidth(drawable);
int height = getDrawableHeight(drawable);
RectF imgRect = new RectF(0, 0, width, height);
matrix.mapRect(imgRect);
RectF rect = new RectF(p[0] + imgRect.left, p[1] + imgRect.top, p[0] + imgRect.right, p[1] + imgRect.bottom);
RectF widgetRect = new RectF(0, 0, imgView.getWidth(), imgView.getHeight());
RectF baseRect = new RectF(widgetRect);
PointF screenCenter = new PointF(widgetRect.width() / 2, widgetRect.height() / 2);
return new Info(rect, imgRect, widgetRect, baseRect, screenCenter, 1, 0, imgView.getScaleType());
}
private static void getLocation(View target, int[] position) {
position[0] += target.getLeft();
position[1] += target.getTop();
ViewParent viewParent = target.getParent();
while (viewParent instanceof View) {
final View view = (View) viewParent;
if (view.getId() == android.R.id.content) return;
position[0] -= view.getScrollX();
position[1] -= view.getScrollY();
position[0] += view.getLeft();
position[1] += view.getTop();
viewParent = view.getParent();
}
position[0] = (int) (position[0] + 0.5f);
position[1] = (int) (position[1] + 0.5f);
}
private void reset() {
mAnimaMatrix.reset();
executeTranslate();
mScale = 1;
mTranslateX = 0;
mTranslateY = 0;
}
public interface ClipCalculate {
float calculateTop();
}
public class START implements ClipCalculate {
public float calculateTop() {
return mImgRect.top;
}
}
public class END implements ClipCalculate {
public float calculateTop() {
return mImgRect.bottom;
}
}
public class OTHER implements ClipCalculate {
public float calculateTop() {
return (mImgRect.top + mImgRect.bottom) / 2;
}
}
/**
* 在PhotoView內(nèi)部還沒有圖片的時(shí)候同樣可以調(diào)用該方法
* <p></p>
* 此時(shí)并不會播放動(dòng)畫，當(dāng)給PhotoView設(shè)置圖片后會自動(dòng)播放動(dòng)畫允扇。
* <p></p>
* 若等待時(shí)間過長也沒有給控件設(shè)置圖片缠局，則會忽略該動(dòng)畫，若要再次播放動(dòng)畫則需要重新調(diào)用該方法
* (等待的時(shí)間默認(rèn)500毫秒考润，可以通過setMaxAnimFromWaiteTime(int)設(shè)置最大等待時(shí)間)
*/
public void animaFrom(Info info) {
if (isInit) {
reset();
Info mine = getInfo();
float scaleX = info.mImgRect.width() / mine.mImgRect.width();
float scaleY = info.mImgRect.height() / mine.mImgRect.height();
float scale = scaleX < scaleY ? scaleX : scaleY;
float ocx = info.mRect.left + info.mRect.width() / 2;
float ocy = info.mRect.top + info.mRect.height() / 2;
float mcx = mine.mRect.left + mine.mRect.width() / 2;
float mcy = mine.mRect.top + mine.mRect.height() / 2;
mAnimaMatrix.reset();
// mAnimaMatrix.postTranslate(-mBaseRect.left, -mBaseRect.top);
mAnimaMatrix.postTranslate(ocx - mcx, ocy - mcy);
mAnimaMatrix.postScale(scale, scale, ocx, ocy);
mAnimaMatrix.postRotate(info.mDegrees, ocx, ocy);
executeTranslate();
mScaleCenter.set(ocx, ocy);
mRotateCenter.set(ocx, ocy);
mTranslate.withTranslate(0, 0, (int) -(ocx - mcx), (int) -(ocy - mcy));
mTranslate.withScale(scale, 1);
mTranslate.withRotate((int) info.mDegrees, 0);
if (info.mWidgetRect.width() < info.mImgRect.width() || info.mWidgetRect.height() < info.mImgRect.height()) {
float clipX = info.mWidgetRect.width() / info.mImgRect.width();
float clipY = info.mWidgetRect.height() / info.mImgRect.height();
clipX = clipX > 1 ? 1 : clipX;
clipY = clipY > 1 ? 1 : clipY;
ClipCalculate c = info.mScaleType == ScaleType.FIT_START ? new START() : info.mScaleType == ScaleType.FIT_END ? new END() : new OTHER();
mTranslate.withClip(clipX, clipY, 1 - clipX, 1 - clipY, mAnimaDuring / 3, c);
mTmpMatrix.setScale(clipX, clipY, (mImgRect.left + mImgRect.right) / 2, c.calculateTop());
mTmpMatrix.mapRect(mTranslate.mClipRect, mImgRect);
mClip = mTranslate.mClipRect;
}
mTranslate.start();
} else {
mFromInfo = info;
mInfoTime = System.currentTimeMillis();
}
}
public void animaTo(Info info, Runnable completeCallBack) {
if (isInit) {
mTranslate.stop();
mTranslateX = 0;
mTranslateY = 0;
float tcx = info.mRect.left + info.mRect.width() / 2;
float tcy = info.mRect.top + info.mRect.height() / 2;
mScaleCenter.set(mImgRect.left + mImgRect.width() / 2, mImgRect.top + mImgRect.height() / 2);
mRotateCenter.set(mScaleCenter);
// 將圖片旋轉(zhuǎn)回正常位置狭园，用以計(jì)算
mAnimaMatrix.postRotate(-mDegrees, mScaleCenter.x, mScaleCenter.y);
mAnimaMatrix.mapRect(mImgRect, mBaseRect);
// 縮放
float scaleX = info.mImgRect.width() / mBaseRect.width();
float scaleY = info.mImgRect.height() / mBaseRect.height();
float scale = scaleX > scaleY ? scaleX : scaleY;
mAnimaMatrix.postRotate(mDegrees, mScaleCenter.x, mScaleCenter.y);
mAnimaMatrix.mapRect(mImgRect, mBaseRect);
mDegrees = mDegrees % 360;
mTranslate.withTranslate(0, 0, (int) (tcx - mScaleCenter.x), (int) (tcy - mScaleCenter.y));
mTranslate.withScale(mScale, scale);
mTranslate.withRotate((int) mDegrees, (int) info.mDegrees, mAnimaDuring * 2 / 3);
if (info.mWidgetRect.width() < info.mRect.width() || info.mWidgetRect.height() < info.mRect.height()) {
float clipX = info.mWidgetRect.width() / info.mRect.width();
float clipY = info.mWidgetRect.height() / info.mRect.height();
clipX = clipX > 1 ? 1 : clipX;
clipY = clipY > 1 ? 1 : clipY;
final float cx = clipX;
final float cy = clipY;
final ClipCalculate c = info.mScaleType == ScaleType.FIT_START ? new START() : info.mScaleType == ScaleType.FIT_END ? new END() : new OTHER();
postDelayed(new Runnable() {
@Override
public void run() {
mTranslate.withClip(1, 1, -1 + cx, -1 + cy, mAnimaDuring / 2, c);
}
}, mAnimaDuring / 2);
}
mCompleteCallBack = completeCallBack;
mTranslate.start();
}
}
public void rotate(float degrees) {
mDegrees += degrees;
int centerX = (int) (mWidgetRect.left + mWidgetRect.width() / 2);
int centerY = (int) (mWidgetRect.top + mWidgetRect.height() /2);
mAnimaMatrix.postRotate(degrees, centerX, centerY);
executeTranslate();
}
}
public class RotateGestureDetector {
private static final int MAX_DEGREES_STEP = 120;
private OnRotateListener mListener;
private float mPrevSlope;
private float mCurrSlope;
private float x1;
private float y1;
private float x2;
private float y2;
public RotateGestureDetector(OnRotateListener l) {
mListener = l;
}
public void onTouchEvent(MotionEvent event) {
final int Action = event.getActionMasked();
switch (Action) {
case MotionEvent.ACTION_POINTER_DOWN:
case MotionEvent.ACTION_POINTER_UP:
if (event.getPointerCount() == 2) mPrevSlope = caculateSlope(event);
break;
case MotionEvent.ACTION_MOVE:
if (event.getPointerCount() > 1) {
mCurrSlope = caculateSlope(event);
double currDegrees = Math.toDegrees(Math.atan(mCurrSlope));
double prevDegrees = Math.toDegrees(Math.atan(mPrevSlope));
double deltaSlope = currDegrees - prevDegrees;
if (Math.abs(deltaSlope) <= MAX_DEGREES_STEP) {
mListener.onRotate((float) deltaSlope, (x2 + x1) / 2, (y2 + y1) / 2);
}
mPrevSlope = mCurrSlope;
}
break;
default:
break;
}
}
private float caculateSlope(MotionEvent event) {
x1 = event.getX(0);
y1 = event.getY(0);
x2 = event.getX(1);
y2 = event.getY(1);
return (y2 - y1) / (x2 - x1);
}
}
interface OnRotateListener {
void onRotate(float degrees, float focusX, float focusY);
}
```public class Info {
// 內(nèi)部圖片在整個(gè)手機(jī)界面的位置
RectF mRect = new RectF();
// 控件在窗口的位置
RectF mImgRect = new RectF();
RectF mWidgetRect = new RectF();
RectF mBaseRect = new RectF();
PointF mScreenCenter = new PointF();
float mScale;
float mDegrees;
ImageView.ScaleType mScaleType;
public Info(RectF rect, RectF img, RectF widget, RectF base, PointF screenCenter, float scale, float degrees, ImageView.ScaleType scaleType) {
mRect.set(rect);
mImgRect.set(img);
mWidgetRect.set(widget);
mScale = scale;
mScaleType = scaleType;
mDegrees = degrees;
mBaseRect.set(base);
mScreenCenter.set(screenCenter);
}
}
public class Info {
// 內(nèi)部圖片在整個(gè)手機(jī)界面的位置
RectF mRect = new RectF();
// 控件在窗口的位置
RectF mImgRect = new RectF();
RectF mWidgetRect = new RectF();
RectF mBaseRect = new RectF();
PointF mScreenCenter = new PointF();
float mScale;
float mDegrees;
ImageView.ScaleType mScaleType;
public Info(RectF rect, RectF img, RectF widget, RectF base, PointF screenCenter, float scale, float degrees, ImageView.ScaleType scaleType) {
mRect.set(rect);
mImgRect.set(img);
mWidgetRect.set(widget);
mScale = scale;
mScaleType = scaleType;
mDegrees = degrees;
mBaseRect.set(base);
mScreenCenter.set(screenCenter);
}
}
然后在啟動(dòng)的activity中寫如下代碼：
...
private Intent intent;
private PhotoView imageView;
private String mDatas;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
intent = getIntent();
mDatas = intent.getStringExtra("images");
imageView = new PhotoView(this);
imageView.setScaleType(ImageView.ScaleType.FIT_CENTER);//使圖片充滿整個(gè)屏幕
setContentView(imageView);
RequestOptions requestOptions=RequestOptions.overrideOf(1000,2000).encodeQuality(100).sizeMultiplier(0.5f);//這句代碼很重要，它使得超長圖也可以顯示出來糊治，不然超長圖是顯示不出來的
Glide.with(this).load(mDatas).apply(requestOptions).into(imageView);
imageView.enable();//啟動(dòng)放大唱矛，拖拽
}
...
5：android開發(fā)中ImageView控件上下空間莫名空白塊的原因與解決方法為：在圖片ImageView控件中添加屬性android:adjustViewBounds="true"即可
6：listview的滑動(dòng)監(jiān)聽，示例代碼如下：
...
private MultiColumnListView gridView;
private boolean scrollFlag = false;
private int lastVisibleItemPosition = 0;// 標(biāo)記上次滑動(dòng)位置
...
gridView.setOnScrollListener(new PLA_AbsListView.OnScrollListener() {
@Override
public void onScrollStateChanged(PLA_AbsListView view, int scrollState) {
switch (scrollState) {
// 當(dāng)不滾動(dòng)時(shí)
case PLA_AbsListView.OnScrollListener.SCROLL_STATE_IDLE:// 是當(dāng)屏幕停止?jié)L動(dòng)時(shí)
scrollFlag = false;
break;
case PLA_AbsListView.OnScrollListener.SCROLL_STATE_TOUCH_SCROLL:// 滾動(dòng)時(shí)
scrollFlag = true;
break;
case PLA_AbsListView.OnScrollListener.SCROLL_STATE_FLING:// 是當(dāng)用戶由于之前劃動(dòng)屏幕并抬起手指，屏幕產(chǎn)生慣性滑動(dòng)時(shí)
scrollFlag = false;
break;
}
}
@Override
public void onScroll(PLA_AbsListView view, int firstVisibleItem,
int visibleItemCount, int totalItemCount) {
if (!view.canScrollVertically(-1)) {
Log.d("qwer", "到頂了");
} else if (!view.canScrollVertically(1)) {
Log.d("qwer", "到底了");
}
if (scrollFlag) {
if (firstVisibleItem > lastVisibleItemPosition) {
Log.d("qwer", "向下劃了");
} else if (firstVisibleItem < lastVisibleItemPosition) {
Log.d("qwer", "向上劃了");
} else {
return;
}
lastVisibleItemPosition = firstVisibleItem;
}
}
});
參考文章如下：
https://www.cnblogs.com/manmanlu/p/4512132.html
7：將一個(gè)圖片設(shè)置為手機(jī)的壁紙绎谦，代碼示例如下：
bizhi.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if(tupian.getDrawable()!=null){
bitmap=drawable2Bitmap(tupian.getDrawable());
WallpaperManager wallpaperManager = WallpaperManager.getInstance(TuPianContentActivity.this);
try {
wallpaperManager.setBitmap(bitmap);
Toast.makeText(TuPianContentActivity.this, "壁紙?jiān)O(shè)置成功", Toast.LENGTH_SHORT).show();
} catch (IOException e) {
Toast.makeText(TuPianContentActivity.this, "壁紙?jiān)O(shè)置失敗", Toast.LENGTH_SHORT).show();
e.printStackTrace();
}
}else {
Toast.makeText(TuPianContentActivity.this, "請稍后重試", Toast.LENGTH_SHORT).show();
}
}
});
}
參考文章如下
https://www.cnblogs.com/obullxl/archive/2011/06/09/android-sdcard-image-wallpager.html
8：SharedPreferences存儲數(shù)據(jù)的時(shí)候記得在commit方法前面調(diào)用apply方法管闷，可以防止數(shù)據(jù)保存失敗，示例代碼如下：
edit.apply();
edit.commit();
9：把那個(gè)文件管理器的代碼也記錄一下窃肠，挺好的一個(gè)項(xiàng)目包个，github地址如下：
https://github.com/zyj1609wz/FileManager
10：兩種監(jiān)聽按下返回鍵的方式，當(dāng)時(shí)有一種在我的項(xiàng)目里面沒反應(yīng)冤留，但是另外一種方式卻可以用赃蛛，示例代碼如下：
// 捕獲返回鍵的方法1
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
if (keyCode == KeyEvent.KEYCODE_BACK && event.getRepeatCount() == 0) {
// 按下BACK信粮，同時(shí)沒有重復(fù)
Log.d(TAG, "onKeyDown()");
}
return super.onKeyDown(keyCode, event);
}
// 捕獲返回鍵的方法2
@Override
public void onBackPressed() {
Log.d(TAG, "onBackPressed()");
super.onBackPressed();
}
參考網(wǎng)址如下：
https://blog.csdn.net/zhangphil/article/details/45691205
11：瀑布流的實(shí)現(xiàn)沛硅，用recycleview實(shí)現(xiàn)的瀑布流快速滑動(dòng)的話會出現(xiàn)錯(cuò)位的情況，首先需要自定義的imageview查坪，不能用系統(tǒng)的imageview肪跋，其次不能用glide等第三方圖片加載庫歧蒋，需要用自定義的圖片加載類，最后還用到了占位圖州既。最后配上PinterestLikeAdapterView谜洽，github地址為https://github.com/GDG-Korea/PinterestLikeAdapterView即可實(shí)現(xiàn)瀑布流，記住必須要用以下的自定義imageview和加載圖片的類然后和PinterestLikeAdapterView配合才能實(shí)現(xiàn)瀑布流吴叶，單是PinterestLikeAdapterView是無法實(shí)現(xiàn)的阐虚。
參考文章如下：
http://www.jcodecraeer.com/a/anzhuokaifa/androidkaifa/2014/0919/1696.html
自定義imageview代碼如下：
public class ScaleImageView extends ImageView {
private ImageChangeListener imageChangeListener;
private boolean scaleToWidth = false; // this flag determines if should measure height manually dependent of width
public ScaleImageView(Context context) {
super(context);
init();
}
public ScaleImageView(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
init();
}
public ScaleImageView(Context context, AttributeSet attrs) {
super(context, attrs);
init();
}
private void init(){
this.setScaleType(ScaleType.CENTER_INSIDE);
}
@Override
public void setImageBitmap(Bitmap bm) {
super.setImageBitmap(bm);
if (imageChangeListener != null)
imageChangeListener.changed((bm == null));
}
@Override
public void setImageDrawable(Drawable d) {
super.setImageDrawable(d);
if (imageChangeListener != null)
imageChangeListener.changed((d == null));
}
@Override
public void setImageResource(int id){
super.setImageResource(id);
}
public interface ImageChangeListener {
// a callback for when a change has been made to this imageView
void changed(boolean isEmpty);
}
public ImageChangeListener getImageChangeListener() {
return imageChangeListener;
}
public void setImageChangeListener(ImageChangeListener imageChangeListener) {
this.imageChangeListener = imageChangeListener;
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
int widthMode = MeasureSpec.getMode(widthMeasureSpec);
int heightMode = MeasureSpec.getMode(heightMeasureSpec);
int width = MeasureSpec.getSize(widthMeasureSpec);
int height = MeasureSpec.getSize(heightMeasureSpec);
/**
* if both width and height are set scale width first. modify in future if necessary
*/
if(widthMode == MeasureSpec.EXACTLY || widthMode == MeasureSpec.AT_MOST){
scaleToWidth = true;
}else if(heightMode == MeasureSpec.EXACTLY || heightMode == MeasureSpec.AT_MOST){
scaleToWidth = false;
}else throw new IllegalStateException("width or height needs to be set to match_parent or a specific dimension");
if(getDrawable()==null || getDrawable().getIntrinsicWidth()==0 ){
// nothing to measure
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
return;
}else{
if(scaleToWidth){
int iw = this.getDrawable().getIntrinsicWidth();
int ih = this.getDrawable().getIntrinsicHeight();
int heightC = width*ih/iw;
if(height > 0)
if(heightC>height){
// dont let hegiht be greater then set max
heightC = height;
width = heightC*iw/ih;
}
this.setScaleType(ScaleType.CENTER_CROP);
setMeasuredDimension(width, heightC);
}else{
// need to scale to height instead
int marg = 0;
if(getParent()!=null){
if(getParent().getParent()!=null){
marg+= ((RelativeLayout) getParent().getParent()).getPaddingTop();
marg+= ((RelativeLayout) getParent().getParent()).getPaddingBottom();
}
}
int iw = this.getDrawable().getIntrinsicWidth();
int ih = this.getDrawable().getIntrinsicHeight();
width = height*iw/ih;
height-=marg;
setMeasuredDimension(width, height);
}
}
}
}
自定義圖片加載器代碼如下(既可以加載網(wǎng)絡(luò)圖片，也可以加載本地圖片)：
public class ImageLoader {
MemoryCache memoryCache = new MemoryCache();
FileCache fileCache;
private Map<ImageView, String> imageViews = Collections.synchronizedMap(new WeakHashMap<ImageView, String>());
ExecutorService executorService;
Handler handler = new Handler();//handler to display images in UI thread
public ImageLoader(Context context) {
fileCache = new FileCache(context);
executorService = Executors.newFixedThreadPool(5);
}
// final int stub_id= android.R.drawable.alert_dark_frame;
public void DisplayImage(String url, ImageView imageView) {
imageViews.put(imageView, url);
Bitmap bitmap = memoryCache.get(url);
if (bitmap != null)
imageView.setImageBitmap(bitmap);
else {
queuePhoto(url, imageView);
imageView.setImageDrawable(null);
}
}
private void queuePhoto(String url, ImageView imageView) {
PhotoToLoad p = new PhotoToLoad(url, imageView);
executorService.submit(new PhotosLoader(p));
}
private Bitmap getBitmap(String url) {
File f = fileCache.getFile(url);
//from SD cache
Bitmap b = decodeFile(f);
if (b != null)
return b;
//from web
try {
try {
if (url.startsWith("/storage/emulated")) {
return ImageUtil.getLoacalBitmap(url);
}
} catch (Throwable ex) {
ex.printStackTrace();
if (ex instanceof OutOfMemoryError)
memoryCache.clear();
return null;
}
Bitmap bitmap = null;
URL imageUrl = new URL(url);
HttpURLConnection conn = (HttpURLConnection) imageUrl.openConnection();
conn.setConnectTimeout(30000);
conn.setReadTimeout(30000);
conn.setInstanceFollowRedirects(true);
InputStream is = conn.getInputStream();
OutputStream os = new FileOutputStream(f);
Utils.CopyStream(is, os);
os.close();
bitmap = decodeFile(f);
return bitmap;
} catch (Throwable ex) {
ex.printStackTrace();
if (ex instanceof OutOfMemoryError)
memoryCache.clear();
return null;
}
}
//decodes image and scales it to reduce memory consumption
private Bitmap decodeFile(File f) {
try {
//decode image size
BitmapFactory.Options o = new BitmapFactory.Options();
o.inJustDecodeBounds = true;
FileInputStream stream1 = new FileInputStream(f);
BitmapFactory.decodeStream(stream1, null, o);
stream1.close();
//Find the correct scale value. It should be the power of 2.
final int REQUIRED_SIZE = 70;
int width_tmp = o.outWidth, height_tmp = o.outHeight;
int scale = 1;
while (true) {
if (width_tmp / 2 < REQUIRED_SIZE || height_tmp / 2 < REQUIRED_SIZE)
break;
width_tmp /= 2;
height_tmp /= 2;
scale *= 2;
}
if (scale >= 2) {
scale /= 2;
}
//decode with inSampleSize
BitmapFactory.Options o2 = new BitmapFactory.Options();
o2.inSampleSize = scale;
FileInputStream stream2 = new FileInputStream(f);
Bitmap bitmap = BitmapFactory.decodeStream(stream2, null, o2);
stream2.close();
return bitmap;
} catch (FileNotFoundException e) {
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
//Task for the queue
private class PhotoToLoad {
public String url;
public ImageView imageView;
public PhotoToLoad(String u, ImageView i) {
url = u;
imageView = i;
}
}
class PhotosLoader implements Runnable {
PhotoToLoad photoToLoad;
PhotosLoader(PhotoToLoad photoToLoad) {
this.photoToLoad = photoToLoad;
}
@Override
public void run() {
try {
if (imageViewReused(photoToLoad))
return;
Bitmap bmp = getBitmap(photoToLoad.url);
memoryCache.put(photoToLoad.url, bmp);
if (imageViewReused(photoToLoad))
return;
BitmapDisplayer bd = new BitmapDisplayer(bmp, photoToLoad);
handler.post(bd);
} catch (Throwable th) {
th.printStackTrace();
}
}
}
boolean imageViewReused(PhotoToLoad photoToLoad) {
String tag = imageViews.get(photoToLoad.imageView);
if (tag == null || !tag.equals(photoToLoad.url))
return true;
return false;
}
//Used to display bitmap in the UI thread
class BitmapDisplayer implements Runnable {
Bitmap bitmap;
PhotoToLoad photoToLoad;
public BitmapDisplayer(Bitmap b, PhotoToLoad p) {
bitmap = b;
photoToLoad = p;
}
public void run() {
if (imageViewReused(photoToLoad))
return;
if (bitmap != null)
photoToLoad.imageView.setImageBitmap(bitmap);
else
photoToLoad.imageView.setImageDrawable(null);
}
}
public void clearCache() {
memoryCache.clear();
fileCache.clear();
}
}
12：在使用SmartRefreshLayout時(shí)蚌卤，切記要將所有的子view用LinearLayout包起來实束，不然會出現(xiàn)各種奇怪的滑動(dòng)問題
13：給圓形progressbar設(shè)置顏色的方法
https://blog.csdn.net/yzj5380/article/details/69947440
