android+动态翻页,android酷炫翻页效果+图形分析

最新推荐文章于 2024-04-21 09:02:22 发布
最新推荐文章于 2024-04-21 09:02:22 发布
阅读量340 收藏 1
点赞数
文章标签： android+动态翻页

a4c26d1e5885305701be709a3d33442f.png

public class PageWidget extends View {

private static final String TAG = "hmg";

private int mWidth = 480;

private int mHeight = 800;

private int mCornerX = 0; // 拖拽点对应的页脚

private int mCornerY = 0;

private Path mPath0;

private Path mPath1;

Bitmap mCurPageBitmap = null; // 当前页

Bitmap mCurPageBackBitmap = null;

Bitmap mNextPageBitmap = null;

PointF mTouch = new PointF(); // 拖拽点

PointF mBezierStart1 = new PointF(); //

贝塞尔曲线起始点

PointF mBezierControl1 = new PointF(); //

贝塞尔曲线控制点

PointF mBeziervertex1 = new PointF(); //

贝塞尔曲线顶点

PointF mBezierEnd1 = new PointF(); //

贝塞尔曲线结束点

PointF mBezierStart2 = new PointF(); //

另一条贝塞尔曲线起点

PointF mBezierControl2 = new

PointF();//贝塞尔曲线的控制点

PointF mBeziervertex2 = new

PointF();//贝塞尔曲线的顶点

PointF mBezierEnd2 = new PointF();//贝塞尔曲线的结束点

float mMiddleX;

float mMiddleY;

float mDegrees;

float mTouchToCornerDis;

ColorMatrixColorFilter mColorMatrixFilter;

Matrix mMatrix;

float[] mMatrixArray = { 0, 0, 0, 0, 0, 0, 0, 0,

1.0f };

boolean mIsRTandLB; // 是否属于右上左下

// for test

float mMaxLength = (float) Math.hypot(480,

800);

int[] mBackShadowColors;

int[] mFrontShadowColors;

GradientDrawable mBackShadowDrawableLR;

GradientDrawable mBackShadowDrawableRL;

GradientDrawable mFolderShadowDrawableLR;

GradientDrawable mFolderShadowDrawableRL;

GradientDrawable

mFrontShadowDrawableHBT;

GradientDrawable mFrontShadowDrawableHTB;

GradientDrawable mFrontShadowDrawableVLR;

GradientDrawable mFrontShadowDrawableVRL;

private Bitmap mBitmap;

private Canvas mCanvas;

private Paint mBitmapPaint;

Paint paint;

Paint mPaint;

public PageWidget(Context context) {

super(context);

// TODO Auto-generated

constructor stub

mPath0 = new Path();

mPath1 = new Path();

createDrawable();

//

---------------------------------------

mBitmap =

Bitmap.createBitmap(480, 800, Bitmap.Config.ARGB_8888);

mCanvas = new

Canvas(mBitmap);

mBitmapPaint = new

Paint(Paint.DITHER_FLAG);

paint = new Paint();

mPaint = new Paint();

mPaint.setStyle(Paint.Style.FILL);

mCurPageBitmap =

BitmapFactory.decodeResource(this.getResources(),

R.drawable.page1);

mNextPageBitmap =

BitmapFactory.decodeResource(this.getResources(),

R.drawable.page2);

ColorMatrix cm = new

ColorMatrix();

float array[] = { 0.55f, 0, 0,

0, 80.0f, 0, 0.55f, 0, 0, 80.0f, 0, 0,

0.55f,

0, 80.0f, 0, 0, 0, 0.2f, 0 };

cm.set(array);

mColorMatrixFilter = new

ColorMatrixColorFilter(cm);

mMatrix = new

Matrix();

}

private void calcCornerXY(float x, float y)

{

if (x <= mWidth

/ 2)

mCornerX =

0;

else

mCornerX =

mWidth;

if (y <= mHeight

/ 2)

mCornerY =

0;

else

mCornerY =

mHeight;

if ((mCornerX == 0

&& mCornerY == mHeight)

||

(mCornerX == mWidth && mCornerY ==

0))

mIsRTandLB =

true;

else

mIsRTandLB =

false;

}

@Override

public boolean onTouchEvent(MotionEvent event)

{

// TODO Auto-generated method

stub

if (event.getAction() ==

MotionEvent.ACTION_MOVE) {

mCanvas.drawColor(0xFFAAAAAA);

mTouch.x =

event.getX();

mTouch.y =

event.getY();

this.postInvalidate();

}

if (event.getAction() ==

MotionEvent.ACTION_DOWN) {

mCanvas.drawColor(0xFFAAAAAA);

mTouch.x =

event.getX();

mTouch.y =

event.getY();

calcCornerXY(mTouch.x,

mTouch.y);

this.postInvalidate();

}

if (event.getAction() ==

MotionEvent.ACTION_UP) {

mCanvas.drawColor(0xFFAAAAAA);

mTouch.x =

mCornerX;

mTouch.y =

mCornerY;

this.postInvalidate();

}

// return

super.onTouchEvent(event);

return true;

}

public PointF getCross(PointF P1, PointF P2,

PointF P3, PointF P4) {

PointF CrossP = new

PointF();

// 二元函数通式： y=ax+b

float a1 = (P2.y - P1.y) /

(P2.x - P1.x);

float b1 = ((P1.x * P2.y) -

(P2.x * P1.y)) / (P1.x - P2.x);

float a2 = (P4.y - P3.y) /

(P4.x - P3.x);

float b2 = ((P3.x * P4.y) -

(P4.x * P3.y)) / (P3.x - P4.x);

CrossP.x = (b2 - b1) / (a1 -

a2);

CrossP.y = a1 * CrossP.x +

b1;

return CrossP;

}

private void calcPoints() {

mMiddleX = (mTouch.x +

mCornerX) / 2;

mMiddleY = (mTouch.y +

mCornerY) / 2;

Log.i("Log",mTouch.x+"----------------x");

Log.i("Log",mTouch.y+"----------------y");

Log.i("Log",mCornerX+"----------------cornerX");

Log.i("Log",mCornerY+"----------------cornerY");

//贝塞尔曲线的控制点的横坐标

mBezierControl1.x = mMiddleX -

(mCornerY - mMiddleY)

*

(mCornerY - mMiddleY) / (mCornerX - mMiddleX);

mBezierControl1.y =

mCornerY;

Log.i("Log",mBezierControl1.x+"----------------mBezierControl1X");

Log.i("Log",mBezierControl1.y+"----------------mBezierControl1Y");

mBezierControl2.x =

mCornerX;

mBezierControl2.y = mMiddleY -

(mCornerX - mMiddleX)

*

(mCornerX - mMiddleX) / (mCornerY - mMiddleY);

Log.i("hmg",

"mTouchX " + mTouch.x + " mTouchY " + mTouch.y);

Log.i("hmg",

"mBezierControl1.x " + mBezierControl1.x

+

" mBezierControl1.y " +

mBezierControl1.y);

Log.i("hmg",

"mBezierControl2.x " + mBezierControl2.x

+

" mBezierControl2.y " +

mBezierControl2.y);

mBezierStart1.x =

mBezierControl1.x - (mCornerX - mBezierControl1.x)

/

2;

mBezierStart1.y =

mCornerY;

// 当mBezierStart1.x

< 0或者mBezierStart1.x > 480时

// 如果继续翻页，会出现BUG故在此限制

if (mBezierStart1.x

< 0 || mBezierStart1.x > 480) {

Log.i("Log","page

move");

if

(mBezierStart1.x <

0) mBezierStart1.x

= mWidth - mBezierStart1.x;

float f1 =

Math.abs(mCornerX - mTouch.x);

float f2 =

mWidth * f1 / mBezierStart1.x;

mTouch.x =

Math.abs(mCornerX - f2);

float f3 =

Math.abs(mCornerX - mTouch.x)

*

Math.abs(mCornerY - mTouch.y) / f1;

mTouch.y =

Math.abs(mCornerY - f3);

mMiddleX =

(mTouch.x + mCornerX) / 2;

mMiddleY =

(mTouch.y + mCornerY) / 2;

mBezierControl1.x

= mMiddleX - (mCornerY - mMiddleY)

*

(mCornerY - mMiddleY) / (mCornerX - mMiddleX);

mBezierControl1.y

= mCornerY;

mBezierControl2.x

= mCornerX;

mBezierControl2.y

= mMiddleY - (mCornerX - mMiddleX)

*

(mCornerX - mMiddleX) / (mCornerY - mMiddleY);

Log.i("hmg",

"mTouchX --> " + mTouch.x + " mTouchY--> "

+

mTouch.y);

Log.i("hmg",

"mBezierControl1.x-- " + mBezierControl1.x

+

" mBezierControl1.y -- " +

mBezierControl1.y);

Log.i("hmg",

"mBezierControl2.x -- " + mBezierControl2.x

+

" mBezierControl2.y -- " +

mBezierControl2.y);

mBezierStart1.x

= mBezierControl1.x

-

(mCornerX - mBezierControl1.x) / 2;

}

mBezierStart2.x =

mCornerX;

mBezierStart2.y =

mBezierControl2.y - (mCornerY - mBezierControl2.y)

/

2;

mTouchToCornerDis = (float)

Math.hypot((mTouch.x - mCornerX),

(mTouch.y

- mCornerY));

//两条贝塞尔曲线的终点的坐标值

mBezierEnd1 = getCross(mTouch,

mBezierControl1, mBezierStart1,

mBezierStart2);

mBezierEnd2 = getCross(mTouch,

mBezierControl2, mBezierStart1,

mBezierStart2);

Log.i("hmg",

"mBezierEnd1.x " + mBezierEnd1.x +

" mBezierEnd1.y "

+

mBezierEnd1.y);

Log.i("hmg",

"mBezierEnd2.x " + mBezierEnd2.x +

" mBezierEnd2.y "

+

mBezierEnd2.y);

mBeziervertex1.x =

(mBezierStart1.x + 2 * mBezierControl1.x + mBezierEnd1.x) /

4;

mBeziervertex1.y = (2 *

mBezierControl1.y + mBezierStart1.y + mBezierEnd1.y) / 4;

mBeziervertex2.x =

(mBezierStart2.x + 2 * mBezierControl2.x + mBezierEnd2.x) /

4;

mBeziervertex2.y = (2 *

mBezierControl2.y + mBezierStart2.y + mBezierEnd2.y) / 4;

}

private void drawCurrentPageArea(Canvas

canvas, Bitmap bitmap, Path path) {

mPath0.reset();

mPath0.moveTo(mBezierStart1.x,

mBezierStart1.y);

mPath0.quadTo(mBezierControl1.x,

mBezierControl1.y, mBezierEnd1.x,

mBezierEnd1.y);

mPath0.lineTo(mTouch.x,

mTouch.y);

mPath0.lineTo(mBezierEnd2.x,

mBezierEnd2.y);

mPath0.quadTo(mBezierControl2.x,

mBezierControl2.y, mBezierStart2.x,

mBezierStart2.y);

mPath0.lineTo(mCornerX,

mCornerY);

mPath0.close();

canvas.save();

canvas.clipPath(path,

Region.Op.XOR);

canvas.drawBitmap(bitmap, 0, 0,

null);

canvas.restore();

}

private void drawNextPageAreaAndShadow(Canvas

canvas, Bitmap bitmap) {

mPath1.reset();

mPath1.moveTo(mBezierStart1.x,

mBezierStart1.y);

mPath1.lineTo(mBeziervertex1.x,

mBeziervertex1.y);

mPath1.lineTo(mBeziervertex2.x,

mBeziervertex2.y);

mPath1.lineTo(mBezierStart2.x,

mBezierStart2.y);

mPath1.lineTo(mCornerX,

mCornerY);

mPath1.close();

mDegrees = (float)

Math.toDegrees(Math.atan2(mBezierControl1.x

-

mCornerX, mBezierControl2.y - mCornerY));

int leftx;

int rightx;

GradientDrawable

mBackShadowDrawable;

if (mIsRTandLB) {

leftx = (int)

(mBezierStart1.x);

rightx =

(int) (mBezierStart1.x + mTouchToCornerDis / 4);

mBackShadowDrawable

= mBackShadowDrawableLR;

} else {

leftx = (int)

(mBezierStart1.x - mTouchToCornerDis / 4);

rightx =

(int) mBezierStart1.x;

mBackShadowDrawable

= mBackShadowDrawableRL;

}

canvas.save();

canvas.clipPath(mPath0);

canvas.clipPath(mPath1,

Region.Op.INTERSECT);

canvas.drawBitmap(bitmap, 0, 0,

null);

canvas.rotate(mDegrees,

mBezierStart1.x, mBezierStart1.y);

mBackShadowDrawable.setBounds(leftx,

(int) mBezierStart1.y, rightx,

(int)

(mMaxLength + mBezierStart1.y));

mBackShadowDrawable.draw(canvas);

canvas.restore();

}

public void setBitmaps(Bitmap bm1, Bitmap bm2,

Bitmap bm3) {

mCurPageBitmap = bm1;

mCurPageBackBitmap = bm2;

mNextPageBitmap = bm3;

}

@Override

protected void onDraw(Canvas canvas) {

Log.i("Log","onDraw");

canvas.drawColor(0xFFAAAAAA);

calcPoints();

drawCurrentPageArea(mCanvas,

mCurPageBitmap, mPath0);

drawNextPageAreaAndShadow(mCanvas,

mNextPageBitmap);

drawCurrentPageShadow(mCanvas);

drawCurrentBackArea(mCanvas,

mCurPageBitmap);

canvas.drawBitmap(mBitmap, 0,

0, mBitmapPaint);

}

private void createDrawable() {

int[] color = { 0x333333,

0xb0333333 };

mFolderShadowDrawableRL = new

GradientDrawable(

GradientDrawable.Orientation.RIGHT_LEFT,

color);

mFolderShadowDrawableRL

.setGradientType(GradientDrawable.LINEAR_GRADIENT);

mFolderShadowDrawableLR =

new GradientDrawable(

GradientDrawable.Orientation.LEFT_RIGHT,

color);

mFolderShadowDrawableLR

.setGradientType(GradientDrawable.LINEAR_GRADIENT);

mBackShadowColors = new

int[] { 0xff111111, 0x111111 };

mBackShadowDrawableRL = new

GradientDrawable(

GradientDrawable.Orientation.RIGHT_LEFT,

mBackShadowColors);

mBackShadowDrawableRL.setGradientType(GradientDrawable.LINEAR_GRADIENT);

mBackShadowDrawableLR = new

GradientDrawable(

GradientDrawable.Orientation.LEFT_RIGHT,

mBackShadowColors);

mBackShadowDrawableLR.setGradientType(GradientDrawable.LINEAR_GRADIENT);

mFrontShadowColors = new

int[] { 0x80111111, 0x111111 };

mFrontShadowDrawableVLR = new

GradientDrawable(

GradientDrawable.Orientation.LEFT_RIGHT,

mFrontShadowColors);

mFrontShadowDrawableVLR

.setGradientType(GradientDrawable.LINEAR_GRADIENT);

mFrontShadowDrawableVRL = new

GradientDrawable(

GradientDrawable.Orientation.RIGHT_LEFT,

mFrontShadowColors);

mFrontShadowDrawableVRL

.setGradientType(GradientDrawable.LINEAR_GRADIENT);

mFrontShadowDrawableHTB =

new GradientDrawable(

GradientDrawable.Orientation.TOP_BOTTOM,

mFrontShadowColors);

mFrontShadowDrawableHTB

.setGradientType(GradientDrawable.LINEAR_GRADIENT);

mFrontShadowDrawableHBT =

new GradientDrawable(

GradientDrawable.Orientation.BOTTOM_TOP,

mFrontShadowColors);

mFrontShadowDrawableHBT

.setGradientType(GradientDrawable.LINEAR_GRADIENT);

}

public void drawCurrentPageShadow(Canvas canvas)

{

double degree;

if (mIsRTandLB) {

degree =

Math.PI

/

4

-

Math.atan2(mBezierControl1.y - mTouch.y, mTouch.x

-

mBezierControl1.x);

} else {

degree =

Math.PI

/

4

-

Math.atan2(mTouch.y - mBezierControl1.y, mTouch.x

-

mBezierControl1.x);

}

//翻起页阴影顶点与touch点的距离

double d1 = (float) 25 * 1.414

* Math.cos(degree);

double d2 = (float) 25 * 1.414

* Math.sin(degree);

float x = (float) (mTouch.x +

d1);

float y;

if (mIsRTandLB) {

y = (float)

(mTouch.y + d2); } else {

y = (float)

(mTouch.y - d2);

}

mPath1.reset();

mPath1.moveTo(x, y);

mPath1.lineTo(mTouch.x,

mTouch.y);

mPath1.lineTo(mBezierControl1.x,

mBezierControl1.y);

mPath1.lineTo(mBezierStart1.x,

mBezierStart1.y);

mPath1.close();

float rotateDegrees;

canvas.save();

canvas.clipPath(mPath0,

Region.Op.XOR);

canvas.clipPath(mPath1,

Region.Op.INTERSECT);

int leftx;

int rightx;

GradientDrawable

mCurrentPageShadow;

if (mIsRTandLB) {

leftx = (int)

(mBezierControl1.x);

rightx =

(int) mBezierControl1.x + 25;

mCurrentPageShadow

= mFrontShadowDrawableVLR;

} else {

leftx = (int)

(mBezierControl1.x - 25);

rightx =

(int) mBezierControl1.x + 1;

mCurrentPageShadow

= mFrontShadowDrawableVRL;

}

rotateDegrees = (float)

Math.toDegrees(Math.atan2(mTouch.x

-

mBezierControl1.x, mBezierControl1.y - mTouch.y));

canvas.rotate(rotateDegrees,

mBezierControl1.x, mBezierControl1.y);

mCurrentPageShadow.setBounds(leftx,

(int)

(mBezierControl1.y - mMaxLength), rightx,

(int)

(mBezierControl1.y));

mCurrentPageShadow.draw(canvas);

canvas.restore();

mPath1.reset();

mPath1.moveTo(x, y);

mPath1.lineTo(mTouch.x,

mTouch.y);

mPath1.lineTo(mBezierControl2.x,

mBezierControl2.y);

mPath1.lineTo(mBezierStart2.x,

mBezierStart2.y);

mPath1.close();

canvas.save();

canvas.clipPath(mPath0,

Region.Op.XOR);

canvas.clipPath(mPath1,

Region.Op.INTERSECT);

if (mIsRTandLB) {

leftx = (int)

(mBezierControl2.y);

rightx =

(int) (mBezierControl2.y + 25);

mCurrentPageShadow

= mFrontShadowDrawableHTB;

} else {

leftx = (int)

(mBezierControl2.y - 25);

rightx =

(int) (mBezierControl2.y + 1);

mCurrentPageShadow

= mFrontShadowDrawableHBT;

}

rotateDegrees = (float)

Math.toDegrees(Math.atan2(mBezierControl2.y

-

mTouch.y, mBezierControl2.x - mTouch.x));

canvas.rotate(rotateDegrees,

mBezierControl2.x, mBezierControl2.y);

float temp;

if (mBezierControl2.y

< 0)

temp =

mBezierControl2.y - 800;

else

temp =

mBezierControl2.y;

int hmg = (int)

Math.hypot(mBezierControl2.x, temp);

if (hmg >

mMaxLength)

mCurrentPageShadow

.setBounds((int)

(mBezierControl2.x - 25) - hmg, leftx,

(int)

(mBezierControl2.x + mMaxLength) - hmg,

rightx);

else

mCurrentPageShadow.setBounds(

(int)

(mBezierControl2.x - mMaxLength), leftx,

(int)

(mBezierControl2.x), rightx);

Log.i("hmg",

"mBezierControl2.x " +

mBezierControl2.x

+

" mBezierControl2.y " +

mBezierControl2.y);

mCurrentPageShadow.draw(canvas);

canvas.restore();

}

private void drawCurrentBackArea(Canvas canvas,

Bitmap bitmap) {

int i = (int) (mBezierStart1.x

+ mBezierControl1.x) / 2;

float f1 = Math.abs(i -

mBezierControl1.x);

int i1 = (int) (mBezierStart2.y

+ mBezierControl2.y) / 2;

float f2 = Math.abs(i1 -

mBezierControl2.y);

float f3 = Math.min(f1,

f2);

mPath1.reset();

mPath1.moveTo(mBeziervertex2.x,

mBeziervertex2.y);

mPath1.lineTo(mBeziervertex1.x,

mBeziervertex1.y);

mPath1.lineTo(mBezierEnd1.x,

mBezierEnd1.y);

mPath1.lineTo(mTouch.x,

mTouch.y);

mPath1.lineTo(mBezierEnd2.x,

mBezierEnd2.y);

mPath1.close();

GradientDrawable

mFolderShadowDrawable;

int left;

int right;

if (mIsRTandLB) {

left = (int)

(mBezierStart1.x - 1);

right = (int)

(mBezierStart1.x + f3 + 1);

mFolderShadowDrawable

= mFolderShadowDrawableLR;

} else {

left= (int)

(mBezierStart1.x - f3 - 1);

right= (int)

(mBezierStart1.x + 1);

mFolderShadowDrawable

= mFolderShadowDrawableRL;

}

canvas.save();

canvas.clipPath(mPath0);

canvas.clipPath(mPath1,

Region.Op.INTERSECT);

mPaint.setColorFilter(mColorMatrixFilter);

float dis = (float)

Math.hypot(mCornerX - mBezierControl1.x,

mBezierControl2.y

- mCornerY);

float f8 = (mCornerX -

mBezierControl1.x) / dis;

float f9 = (mBezierControl2.y -

mCornerY) / dis;

mMatrixArray[0] = 1 - 2 * f9 *

f9;

mMatrixArray[1] = 2 * f8 *

f9;

mMatrixArray[3] =

mMatrixArray[1];

mMatrixArray[4] = 1 - 2 * f8 *

f8;

mMatrix.reset();

mMatrix.setValues(mMatrixArray);

mMatrix.preTranslate(-mBezierControl1.x,

-mBezierControl1.y);

mMatrix.postTranslate(mBezierControl1.x,

mBezierControl1.y);

canvas.drawBitmap(bitmap,

mMatrix, mPaint);

// canvas.drawBitmap(bitmap,

mMatrix, null);

mPaint.setColorFilter(null);

canvas.rotate(mDegrees,

mBezierStart1.x, mBezierStart1.y);

mFolderShadowDrawable.setBounds(left,

(int) mBezierStart1.y, right,

(int)

(mBezierStart1.y + mMaxLength));

mFolderShadowDrawable.draw(canvas);

canvas.restore();

}

}

上面是定义的翻页控件PageWidget

想要测试这个控件很简单定义一个activity

代码如下:

public void onCreate(Bundle

savedInstanceState) {

super.onCreate(savedInstanceState); requestWindowFeature(Window.FEATURE_NO_TITLE);

getWindow().setFlags(

WindowManager.LayoutParams.FLAG_FULLSCREEN,

WindowManager.LayoutParams.FLAG_FULLSCREEN);

setContentView(new PageWidget(this));

}

弗拉衣裤
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Android3D翻页效果的倒计时控件
04-22
在Android应用开发中，创建吸引用户的交互体验是至关重要的，其中一种独特且引人注目的效果就是3D翻页效果。本知识点将详细介绍如何在Android中实现一个具有3D翻页效果的倒计时控件。这个控件不仅能够显示倒计时，还...
超酷炫的Android碎纸机效果推荐
09-01
总的来说，通过集成`PaperShredderView`库并结合XML和Java代码，Android开发者能够轻松地在应用中实现超酷炫的碎纸机动画效果，为用户带来更加生动有趣的使用体验。同时，开发者还可以根据自身需求进行定制和优化，...
android 布局翻页,安卓APP_ 布局（8) —— 基于 RecyclerView 的 ViewPager2翻页
weixin_32027779的博客
05-26 379
viewpager2 是对RecyclerView 的封装(所以viewpager2 自带懒加载方案)，相对于viewpager，在实际项目中，更推荐使用viewpager2 。实现效果目前来说跟viewpager一毛一样 (1)创建viewpager2在activity_main.xml中，更改为LinearLayout布局，再创建viewpager2布局。 如果找不到viewpager2，则需...
自定义Android横向网格列表控件HorizontalGridView(四)
ai1290126635的专栏
06-27 2869
HorizontalGridView.java /* * Copyright (C) 2007 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in complianc
Android ViewPager 3D翻页效果，2024年最新阿里技术四面
最新发布
2401_84103675的博客
04-21 861
PS：之前因为秋招收集的二十套一二线互联网公司Android面试真题 （含BAT、小米、华为、美团、滴滴）和我自己整理Android复习笔记（包含Android基础知识点、Android扩展知识点、Android源码解析、设计模式汇总、Gradle知识点、常见算法题汇总。一共十个专题，包括了Android进阶所有学习资料，Android进阶视频，Flutter，java基础，kotlin，NDK模块，计算机网络，数据结构与算法，微信小程序，面试题解析，framework源码！很快，但一群人才能走的更远！
App 金刚区导航菜单，类似淘宝、QQ 音乐等 APP 导航，方格布局横向滑动翻页带滚动条
未来很长，但我会努力的走下去。
12-23 1984
TransformersLayout 项目地址：zaaach/TransformersLayout 简介： :fire: App 金刚区导航菜单，类似淘宝、QQ 音乐等 APP 导航，方格布局横向滑动翻页带滚动条 更多：作者提 Bug 标签： :fire: APP 金刚区导航布局，下方带横向滚动条，很多 APP 都有使用这种，效果还不错就封装了一下:smil...
Android 网格分页布局。
未来很长，但我会努力的走下去。
01-10 1176
pager-layoutmanager 项目地址：GcsSloop/pager-layoutmanager  简介：Android 网格分页布局。 更多：作者   提 Bug   官网    标签：   具有分页功能的 Recyclerview 布局管理器，主打分页，可以替代部分场景下的网格布局，线性布局，以及一些简单的 ViewPager，但也有一定的局限性，请选择性使用。 网格分...
Android翻页效果原理实现之曲线的实现
热门推荐
AigeStudio
01-14 1万+
尊重原创转载请注明：From AigeStudio（http://blog.csdn.net/aigestudio）Power by Aige 侵权必究！ 炮兵镇楼 上一节我们通过引入折线实现了页面的折叠翻转效果，有了前面两节的基础呢其实曲线的实现可以变得非常简单，为什么这么说呢？因为曲线无非就是在折线的基础上对Path加入了曲线的实现，进而只是影响了我们的Region区域，而其他的什么事
js实现吃豆豆游戏，web优秀课程设计，html+css+js，效果酷炫！
02-17
js实现吃豆豆游戏，web优秀课程设计，html+css+js，效果酷炫！ js实现吃豆豆游戏，web优秀课程设计，html+css+js，效果酷炫！ js实现吃豆豆游戏，web优秀课程设计，html+css+js，效果酷炫！ js实现吃豆豆游戏，web...
android电子书翻页效果
07-11
"android电子书翻页效果"的实现涉及到多个技术层面，包括图形渲染、触摸事件处理、动画设计等。以下是对这个主题的详细阐述： 一、Android绘图基础 Android提供了丰富的绘图API，如Canvas、Paint、Path等，用于在...
Android-CoolAndroidAnim一个酷炫的androidloading效果
08-12
"Android-CoolAndroidAnim"项目就是这样一个专注于提供酷炫Android加载效果的开源库。这个项目源于对Google Nexus 6.0系统开机动画的灵感，旨在为开发者提供一种模仿这种高级动态效果的方法。 首先，我们要理解什么...
Android翻页动画效果完整实例代码
03-13
一个非常实用的小例子，主要实现了模拟书本翻页的效果，类似常用的电子书阅读软件中的翻页效果。超赞哦。。。。。 已经封装成组件，xml直接引用即可，开发接入零成本
Android中用ViewPage实现真实翻页效果
01-10
用ViewPage实现像真实翻页那种效果,个人感觉效果特别好
android flip翻页效果,翻日历效果
03-16
android-flip-翻页效果,很漂亮的Android界面特效，可上下翻折，上下翻页，翻日历效果。使用了一个翻页类库来实现，值得参考。 运行环境：Java/Eclipse
android 真实书籍翻页效果(完结篇)
04-22
这是我博客http://blog.csdn.net/hmg25里android实现书籍翻页效果的代码，截图在我博客里有，希望感兴趣的童鞋研究下~~ 升级篇对应的为： http://download.csdn.net/source/3278901 添加了翻页动画~读取txt
Android翻页特效
05-25
Android翻书翻页特效，Java代码编译，可轻松移植到J2ME平台
Android ViewPager2 实现阅读器横向翻页效果（一）--- ViewPager2的原理及堆叠效果实现
weixin_44370506的博客
10-04 3805
通过Android ViewPager2 实现阅读器横向翻页效果。ViewPager2原理详解，及堆叠效果实现的原理及代码
即使只有一面之缘你也不能放弃＞一年Android社招经验帖
2401_84103616的博客
04-17 1001
PS：之前因为秋招收集的二十套一二线互联网公司Android面试真题 （含BAT、小米、华为、美团、滴滴）和我自己整理Android复习笔记（包含Android基础知识点、Android扩展知识点、Android源码解析、设计模式汇总、Gradle知识点、常见算法题汇总。一共十个专题，包括了Android进阶所有学习资料，Android进阶视频，Flutter，java基础，kotlin，NDK模块，计算机网络，数据结构与算法，微信小程序，面试题解析，framework源码！从cgRoot讲一下;
android的组件widget简介,Flutter widget组件简介
weixin_35739967的博客
05-25 199
一、简介Flutter Widget采用现代响应式框架构建，核心思想是用widget组件来构建UI，当widget的状态发生变化时，widget也会对应重新构建UI，Flutrer会对比前后变化的不同，以确定底层渲染树从一个状态转换到下一个状态所需的最小更改。二、入口程序通过flutter create创建的项目，我们可以看到在lib目录下有一个默认的mian.dart文件，下面来看下这个文件里的...
Android酷炫动画效果之3D星体旋转效果
01-20
在Android中，想要实现酷炫的3D动画效果，一般有两种选择：Open GL ES和Camera。Open GL ES虽然能够实现高级的3D特效或游戏，但使用起来过于复杂，而且并不开源，因此在实现简单的3D效果时，使用Camera就已经足够了...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值