Android FoldingLayout 折叠布局 原理及实现（一）

最新推荐文章于 2024-05-23 18:59:29 发布
最新推荐文章于 2024-05-23 18:59:29 发布
阅读量2.7k 收藏
点赞数
分类专栏： 安卓 文章标签： android
转载请标明出处： http://blog.csdn.net/lmj623565791/article/details/44278417 ，本文出自： 【张鸿洋的博客】

1、概述

无意中翻到的FoldingLayout的介绍的博客，以及github地址。感觉很nice呀，于是花了点时间研究以及编写，本篇博客将带大家从最基本的原理分析，一步一步的实现我们的FoldingLayout，当然了，如果你能力过硬，可以直接下载github上的代码进行学习。

博客基本分为以下几个部分：

1、Matrix的setPolyToPoly使用

2、在图片上使用渐变和阴影

3、初步的FoldingLayout的实现，完成图片的折叠显示（可控制折叠次数、包含阴影的绘制）

4、引入手势，手指可以可以FoldingLayout的折叠

5、结合DrawerLayout实现折叠式侧滑

6、结合SlidingPaneLayout实现折叠式侧滑

ok，贴下部分的效果图：


改图对应上述3，妹子不错吧~

ok，对应上述4.


对应上述5。

ok，挑选了部分图，不然太占篇幅了。

那么接下来，我们就按照顺序往下学习了~~~

2、Matrix的setPolyToPoly使用

想要实现折叠，最重要的就是其核心的原理了，那么第一步我们要了解的就是，如何能把一张正常显示的图片，让它能够进行偏移显示。

其实精髓就在于Matrix的setPolyToPoly的方法。

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public boolean setPolyToPoly(float[] src, int srcIndex, float[] dst, int dstIndex,int pointCount) 
public boolean setPolyToPoly(float[] src, int srcIndex,  float[] dst, int dstIndex,int pointCount)
简单看一下该方法的参数，src代表变换前的坐标；dst代表变换后的坐标；从src到dst的变换，可以通过srcIndex和dstIndex来制定第一个变换的点，一般可能都设置位0。pointCount代表支持的转换坐标的点数，最多支持4个。

如果不明白没事，下面通过一个简单的例子，带大家了解：

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. package com.zhy.sample.folderlayout;
  3. import android.app.Activity;
  4. import android.content.Context;
  5. import android.graphics.Bitmap;
  6. import android.graphics.BitmapFactory;
  7. import android.graphics.Canvas;
  8. import android.graphics.Matrix;
  9. import android.os.Bundle;
  10. import android.view.View;
  12. public class MatrixPolyToPolyActivity extends Activity
  13. {
  15. @Override
  16. protected void onCreate(Bundle savedInstanceState)
  17. {
  18. super.onCreate(savedInstanceState);
  19. setContentView(new PolyToPolyView(this));
  20. }
  22. class PolyToPolyView extends View
  23. {
  25. private Bitmap mBitmap;
  26. private Matrix mMatrix;
  28. public PolyToPolyView(Context context)
  29. {
  30. super(context);
  31. mBitmap = BitmapFactory.decodeResource(getResources(),
  32. R.drawable.tanyan);
  33. mMatrix = new Matrix();
  34. float[] src = { 0, 0,//
  35. mBitmap.getWidth(), 0,//
  36. mBitmap.getWidth(), mBitmap.getHeight(),//
  37. 0, mBitmap.getHeight() };
  38. float[] dst = { 0, 0,//
  39. mBitmap.getWidth(), 100,//
  40. mBitmap.getWidth(), mBitmap.getHeight() - 100,//
  41. 0, mBitmap.getHeight() };
  42. mMatrix.setPolyToPoly(src, 0, dst, 0, src.length >> 1);
  43. }
  45. @Override
  46. protected void onDraw(Canvas canvas)
  47. {
  48. super.onDraw(canvas);
  49. canvas.drawBitmap(mBitmap, mMatrix, null);
  50. }
  52. }
  54. } 
package com.zhy.sample.folderlayout;

import android.app.Activity;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.os.Bundle;
import android.view.View;

public class MatrixPolyToPolyActivity extends Activity
{

	@Override
	protected void onCreate(Bundle savedInstanceState)
	{
		super.onCreate(savedInstanceState);
		setContentView(new PolyToPolyView(this));
	}

	class PolyToPolyView extends View
	{

		private Bitmap mBitmap;
		private Matrix mMatrix;

		public PolyToPolyView(Context context)
		{
			super(context);
			mBitmap = BitmapFactory.decodeResource(getResources(),
					R.drawable.tanyan);
			mMatrix = new Matrix();
			float[] src = { 0, 0,//
					mBitmap.getWidth(), 0,//
					mBitmap.getWidth(), mBitmap.getHeight(),//
					0, mBitmap.getHeight() };
			float[] dst = { 0, 0,//
					mBitmap.getWidth(), 100,//
					mBitmap.getWidth(), mBitmap.getHeight() - 100,//
					0, mBitmap.getHeight() };
			mMatrix.setPolyToPoly(src, 0, dst, 0, src.length >> 1);
		}

		@Override
		protected void onDraw(Canvas canvas)
		{
			super.onDraw(canvas);
			canvas.drawBitmap(mBitmap, mMatrix, null);
		}

	}

}

我们编写了一个PolyToPolyView作为我们的Activity的主视图。

在PolyToPolyView中，我们加载了一张图片，初始化我们的Matrix，注意src和dst两个数组，src就是正常情况下图片的4个顶点。dst将图片右侧两个点的y坐标做了些许的修改。

大家可以在纸上稍微标一下src和dst的四个点的位置。

最后我们在onDraw的时候进行图像的绘制，效果为：


如果你已经在纸上稍微的画了dst的四个点，那么这个结果你一定不陌生。

可以看到我们通过matrix.setPolyToPoly实现了图片的倾斜，那么引入到折叠的情况，假设折叠两次，大家有思路么，考虑一下，没有的话，继续往下看。

3、引入阴影

其实阴影应该在实现初步的折叠以后来说，这样演示其实比较方便，但是为了降低其理解的简单性，我们先把阴影抽取出来说。

假设我们现在要给上图加上阴影，希望的效果图是这样的：


可以看到我们左侧加入了一点阴影，怎么实现呢？

主要还是利用LinearGradient，我们从左到右添加一层从黑色到透明的渐变即可。

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public class MatrixPolyToPolyWithShadowActivity extends Activity
  2. {
  4. @Override
  5. protected void onCreate(Bundle savedInstanceState)
  6. {
  7. super.onCreate(savedInstanceState);
  8. setContentView(new PolyToPolyView(this));
  10. }
  12. class PolyToPolyView extends View
  13. {
  15. private Bitmap mBitmap;
  16. private Matrix mMatrix;
  18. private Paint mShadowPaint;
  19. private Matrix mShadowGradientMatrix;
  20. private LinearGradient mShadowGradientShader;
  22. public PolyToPolyView(Context context)
  23. {
  24. super(context);
  25. mBitmap = BitmapFactory.decodeResource(getResources(),
  26. R.drawable.tanyan);
  27. mMatrix = new Matrix();
  29. mShadowPaint = new Paint();
  30. mShadowPaint.setStyle(Style.FILL);
  31. mShadowGradientShader = new LinearGradient(0, 0, 0.5f, 0,
  32. Color.BLACK, Color.TRANSPARENT, TileMode.CLAMP);
  33. mShadowPaint.setShader(mShadowGradientShader);
  35. mShadowGradientMatrix = new Matrix();
  36. mShadowGradientMatrix.setScale(mBitmap.getWidth(), 1);
  37. mShadowGradientShader.setLocalMatrix(mShadowGradientMatrix);
  38. mShadowPaint.setAlpha((int) (0.9*255));
  40. }
  42. @Override
  43. protected void onDraw(Canvas canvas)
  44. {
  45. super.onDraw(canvas);
  46. canvas.save();
  47. float[] src = //...;
  48. float[] dst = //...;
  49. mMatrix.setPolyToPoly(src, 0, dst, 0, src.length >> 1);
  51. canvas.concat(mMatrix);
  52. canvas.drawBitmap(mBitmap, 0, 0, null);
  53. //绘制阴影 canvas.drawRect(0, 0, mBitmap.getWidth(), mBitmap.getHeight(),
  54. mShadowPaint);
  55. canvas.restore();
  57. }
  59. }
  61. } 
public class MatrixPolyToPolyWithShadowActivity extends Activity
{

	@Override
	protected void onCreate(Bundle savedInstanceState)
	{
		super.onCreate(savedInstanceState);
		setContentView(new PolyToPolyView(this));

	}

	class PolyToPolyView extends View
	{

		private Bitmap mBitmap;
		private Matrix mMatrix;
		
		private Paint mShadowPaint;
		private Matrix mShadowGradientMatrix;
		private LinearGradient mShadowGradientShader;

		public PolyToPolyView(Context context)
		{
			super(context);
			mBitmap = BitmapFactory.decodeResource(getResources(),
					R.drawable.tanyan);
			mMatrix = new Matrix();

			mShadowPaint = new Paint();
			mShadowPaint.setStyle(Style.FILL);
			mShadowGradientShader = new LinearGradient(0, 0, 0.5f, 0,
					Color.BLACK, Color.TRANSPARENT, TileMode.CLAMP);
			mShadowPaint.setShader(mShadowGradientShader);

			mShadowGradientMatrix = new Matrix();
			mShadowGradientMatrix.setScale(mBitmap.getWidth(), 1);
			mShadowGradientShader.setLocalMatrix(mShadowGradientMatrix);
			mShadowPaint.setAlpha((int) (0.9*255));

		}

		@Override
		protected void onDraw(Canvas canvas)
		{
			super.onDraw(canvas);
			canvas.save();
			float[] src = //...;
			float[] dst = //...;
			mMatrix.setPolyToPoly(src, 0, dst, 0, src.length >> 1);

			canvas.concat(mMatrix);
			canvas.drawBitmap(mBitmap, 0, 0, null);
			//绘制阴影                                                                                                                        canvas.drawRect(0, 0, mBitmap.getWidth(), mBitmap.getHeight(),
					mShadowPaint);
			canvas.restore();

		}

	}

}

重点看mShadowPaint，mShadowGradientShader，mShadowGradientMatrix一个是画笔，我们为画笔设置了一个渐变的Shader，这个Shader的参数为

new LinearGradient(0, 0, 0.5f, 0,Color.BLACK, Color.TRANSPARENT, TileMode.CLAMP);

起点（0，0）、终点（0.5f，0）；颜色从和BLACK到透明；模式为CLAMP，也就是拉伸最后一个像素。

这里你可能会问，这才为0.5个像素的区域设置了渐变，不对呀，恩，是的，继续看接下来我们使用了setLocalMatrix(mShadowGradientMatrix);，而这个

mShadowGradientMatrix将和坐标扩大了mBitmap.getWidth()倍，也就是说现在设置渐变的区域为（0.5f*mBitmap.getWidth()，0）半张图的大小，那么后半张图呢？

后半张应用CLAMP模式，拉伸的透明。

关于Shader、setLocalMatrix等用法也可以参考：Android BitmapShader 实战 实现圆形、圆角图片

4、初步实现折叠

了解了原理以及阴影的绘制以后，接下来要开始学习真正的去折叠了，我们的目标效果为：


妹子折叠成了8份，且阴影的范围为：每个沉下去夹缝的左右两侧，左侧黑色半透明遮盖，右侧短距离的黑色到透明阴影（大家可以仔细看）。

现在其实大家以及会将图片简单倾斜和添加阴影了，那么唯一的难点就是怎么将一张图分成很多快，我相信每块的折叠大家都会。

其实我们可以通过绘制该图多次，比如第一次绘制往下倾斜；第二次绘制网上倾斜；这样就和我们标题2的实现类似了，只需要利用setPolyToPoly。

那么绘制多次，每次显示肯定不是一整张图，比如第一次，我只想显示第一块，所以我们还需要clipRect的配合，说到这，应该以及揭秘了~~~

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. package com.zhy.sample.folderlayout;
  3. import android.app.Activity;
  4. import android.content.Context;
  5. import android.graphics.Bitmap;
  6. import android.graphics.BitmapFactory;
  7. import android.graphics.Canvas;
  8. import android.graphics.Color;
  9. import android.graphics.LinearGradient;
  10. import android.graphics.Matrix;
  11. import android.graphics.Paint;
  12. import android.graphics.Paint.Style;
  13. import android.graphics.Shader.TileMode;
  14. import android.os.Bundle;
  15. import android.view.View;
  17. public class SimpleUseActivity extends Activity
  18. {
  20. @Override
  21. protected void onCreate(Bundle savedInstanceState)
  22. {
  23. super.onCreate(savedInstanceState);
  24. setContentView(new PolyToPolyView(this));
  26. }
  28. class PolyToPolyView extends View
  29. {
  31. private static final int NUM_OF_POINT = 8;
  32. /**
  33. * 图片的折叠后的总宽度
  34. */
  35. private int mTranslateDis;
  37. /**
  38. * 折叠后的总宽度与原图宽度的比例
  39. */
  40. private float mFactor = 0.8f;
  41. /**
  42. * 折叠块的个数
  43. */
  44. private int mNumOfFolds = 8;
  46. private Matrix[] mMatrices = new Matrix[mNumOfFolds];
  48. private Bitmap mBitmap;
  50. /**
  51. * 绘制黑色透明区域
  52. */
  53. private Paint mSolidPaint;
  55. /**
  56. * 绘制阴影
  57. */
  58. private Paint mShadowPaint;
  59. private Matrix mShadowGradientMatrix;
  60. private LinearGradient mShadowGradientShader;
  62. /***
  63. * 原图每块的宽度
  64. */
  65. private int mFlodWidth;
  66. /**
  67. * 折叠时，每块的宽度
  68. */
  69. private int mTranslateDisPerFlod;
  71. public PolyToPolyView(Context context)
  72. {
  73. super(context);
  74. mBitmap = BitmapFactory.decodeResource(getResources(),
  75. R.drawable.tanyan);
  77. //折叠后的总宽度
  78. mTranslateDis = (int) (mBitmap.getWidth() * mFactor);
  79. //原图每块的宽度
  80. mFlodWidth = mBitmap.getWidth() / mNumOfFolds;
  81. //折叠时，每块的宽度
  82. mTranslateDisPerFlod = mTranslateDis / mNumOfFolds;
  84. //初始化matrix
  85. for (int i = 0; i < mNumOfFolds; i++)
  86. {
  87. mMatrices[i] = new Matrix();
  88. }
  90. mSolidPaint = new Paint();
  91. int alpha = (int) (255 * mFactor * 0.8f) ;
  92. mSolidPaint
  93. .setColor(Color.argb((int) (alpha*0.8F), 0, 0, 0));
  95. mShadowPaint = new Paint();
  96. mShadowPaint.setStyle(Style.FILL);
  97. mShadowGradientShader = new LinearGradient(0, 0, 0.5f, 0,
  98. Color.BLACK, Color.TRANSPARENT, TileMode.CLAMP);
  99. mShadowPaint.setShader(mShadowGradientShader);
  100. mShadowGradientMatrix = new Matrix();
  101. mShadowGradientMatrix.setScale(mFlodWidth, 1);
  102. mShadowGradientShader.setLocalMatrix(mShadowGradientMatrix);
  103. mShadowPaint.setAlpha(alpha);
  105. //纵轴减小的那个高度，用勾股定理计算下
  106. int depth = (int) Math.sqrt(mFlodWidth * mFlodWidth
  107. - mTranslateDisPerFlod * mTranslateDisPerFlod)/2;
  109. //转换点
  110. float[] src = new float[NUM_OF_POINT];
  111. float[] dst = new float[NUM_OF_POINT];
  113. /**
  114. * 原图的每一块，对应折叠后的每一块，方向为左上、右上、右下、左下，大家在纸上自己画下
  115. */
  116. for (int i = 0; i < mNumOfFolds; i++)
  117. {
  118. src[0] = i * mFlodWidth;
  119. src[1] = 0;
  120. src[2] = src[0] + mFlodWidth;
  121. src[3] = 0;
  122. src[4] = src[2];
  123. src[5] = mBitmap.getHeight();
  124. src[6] = src[0];
  125. src[7] = src[5];
  127. boolean isEven = i % 2 == 0;
  129. dst[0] = i * mTranslateDisPerFlod;
  130. dst[1] = isEven ? 0 : depth;
  131. dst[2] = dst[0] + mTranslateDisPerFlod;
  132. dst[3] = isEven ? depth : 0;
  133. dst[4] = dst[2];
  134. dst[5] = isEven ? mBitmap.getHeight() - depth : mBitmap
  135. .getHeight();
  136. dst[6] = dst[0];
  137. dst[7] = isEven ? mBitmap.getHeight() : mBitmap.getHeight()
  138. - depth;
  140. //setPolyToPoly
  141. mMatrices[i].setPolyToPoly(src, 0, dst, 0, src.length >> 1);
  142. }
  144. }
  146. @Override
  147. protected void onDraw(Canvas canvas)
  148. {
  149. super.onDraw(canvas);
  150. //绘制mNumOfFolds次
  151. for (int i = 0; i < mNumOfFolds; i++)
  152. {
  154. canvas.save();
  155. //将matrix应用到canvas
  156. canvas.concat(mMatrices[i]);
  157. //控制显示的大小
  158. canvas.clipRect(mFlodWidth * i, 0, mFlodWidth * i + mFlodWidth,
  159. mBitmap.getHeight());
  160. //绘制图片
  161. canvas.drawBitmap(mBitmap, 0, 0, null);
  162. //移动绘制阴影
  163. canvas.translate(mFlodWidth * i, 0);
  164. if (i % 2 == 0)
  165. {
  166. //绘制黑色遮盖
  167. canvas.drawRect(0, 0, mFlodWidth, mBitmap.getHeight(),
  168. mSolidPaint);
  169. }else
  170. {
  171. //绘制阴影
  172. canvas.drawRect(0, 0, mFlodWidth, mBitmap.getHeight(),
  173. mShadowPaint);
  174. }
  175. canvas.restore();
  176. }
  178. }
  180. }
  182. } 
package com.zhy.sample.folderlayout;

import android.app.Activity;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.LinearGradient;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.Paint.Style;
import android.graphics.Shader.TileMode;
import android.os.Bundle;
import android.view.View;

public class SimpleUseActivity extends Activity
{

	@Override
	protected void onCreate(Bundle savedInstanceState)
	{
		super.onCreate(savedInstanceState);
		setContentView(new PolyToPolyView(this));

	}

	class PolyToPolyView extends View
	{

		private static final int NUM_OF_POINT = 8;
		/**
		 * 图片的折叠后的总宽度
		 */
		private int mTranslateDis;

		/**
		 * 折叠后的总宽度与原图宽度的比例
		 */
		private float mFactor = 0.8f;
		/**
		 * 折叠块的个数
		 */
		private int mNumOfFolds = 8;

		private Matrix[] mMatrices = new Matrix[mNumOfFolds];
		
		private Bitmap mBitmap;

		/**
		 * 绘制黑色透明区域
		 */
		private Paint mSolidPaint;

		/**
		 * 绘制阴影
		 */
		private Paint mShadowPaint;
		private Matrix mShadowGradientMatrix;
		private LinearGradient mShadowGradientShader;

		/***
		 * 原图每块的宽度
		 */
		private int mFlodWidth;
		/**
		 * 折叠时，每块的宽度
		 */
		private int mTranslateDisPerFlod;

		public PolyToPolyView(Context context)
		{
			super(context);
			mBitmap = BitmapFactory.decodeResource(getResources(),
					R.drawable.tanyan);
			
			//折叠后的总宽度
			mTranslateDis = (int) (mBitmap.getWidth() * mFactor);
			//原图每块的宽度
			mFlodWidth = mBitmap.getWidth() / mNumOfFolds;
			//折叠时，每块的宽度
			mTranslateDisPerFlod = mTranslateDis / mNumOfFolds;
			
			//初始化matrix
			for (int i = 0; i < mNumOfFolds; i++)
			{
				mMatrices[i] = new Matrix();
			}

			mSolidPaint = new Paint();
			int alpha = (int) (255 * mFactor * 0.8f) ;
			mSolidPaint
					.setColor(Color.argb((int) (alpha*0.8F), 0, 0, 0));

			mShadowPaint = new Paint();
			mShadowPaint.setStyle(Style.FILL);
			mShadowGradientShader = new LinearGradient(0, 0, 0.5f, 0,
					Color.BLACK, Color.TRANSPARENT, TileMode.CLAMP);
			mShadowPaint.setShader(mShadowGradientShader);
			mShadowGradientMatrix = new Matrix();
			mShadowGradientMatrix.setScale(mFlodWidth, 1);
			mShadowGradientShader.setLocalMatrix(mShadowGradientMatrix);
			mShadowPaint.setAlpha(alpha);

			//纵轴减小的那个高度，用勾股定理计算下
			int depth = (int) Math.sqrt(mFlodWidth * mFlodWidth
					- mTranslateDisPerFlod * mTranslateDisPerFlod)/2;

			//转换点
			float[] src = new float[NUM_OF_POINT];
			float[] dst = new float[NUM_OF_POINT];

			/**
			 * 原图的每一块，对应折叠后的每一块，方向为左上、右上、右下、左下，大家在纸上自己画下
			 */
			for (int i = 0; i < mNumOfFolds; i++)
			{
				src[0] = i * mFlodWidth;
				src[1] = 0;
				src[2] = src[0] + mFlodWidth;
				src[3] = 0;
				src[4] = src[2];
				src[5] = mBitmap.getHeight();
				src[6] = src[0];
				src[7] = src[5];

				boolean isEven = i % 2 == 0;

				dst[0] = i * mTranslateDisPerFlod;
				dst[1] = isEven ? 0 : depth;
				dst[2] = dst[0] + mTranslateDisPerFlod;
				dst[3] = isEven ? depth : 0;
				dst[4] = dst[2];
				dst[5] = isEven ? mBitmap.getHeight() - depth : mBitmap
						.getHeight();
				dst[6] = dst[0];
				dst[7] = isEven ? mBitmap.getHeight() : mBitmap.getHeight()
						- depth;

				//setPolyToPoly
				mMatrices[i].setPolyToPoly(src, 0, dst, 0, src.length >> 1);
			}

		}

		@Override
		protected void onDraw(Canvas canvas)
		{
			super.onDraw(canvas);
			//绘制mNumOfFolds次
			for (int i = 0; i < mNumOfFolds; i++)
			{
				
				canvas.save();
				//将matrix应用到canvas
				canvas.concat(mMatrices[i]);
				//控制显示的大小
				canvas.clipRect(mFlodWidth * i, 0, mFlodWidth * i + mFlodWidth,
						mBitmap.getHeight());
				//绘制图片
				canvas.drawBitmap(mBitmap, 0, 0, null);
				//移动绘制阴影
				canvas.translate(mFlodWidth * i, 0);
				if (i % 2 == 0)
				{
					//绘制黑色遮盖
					canvas.drawRect(0, 0, mFlodWidth, mBitmap.getHeight(),
							mSolidPaint);
				}else
				{
					//绘制阴影
					canvas.drawRect(0, 0, mFlodWidth, mBitmap.getHeight(),
							mShadowPaint);
				}
				canvas.restore();
			}

		}

	}

}

简单讲解下，不去管绘制阴影的部分，其实折叠就是：

1、初始化转换点，这里注释说的很清楚，大家最好在纸上绘制下，标一下每个变量。

2、为matrix.setPolyToPoly

3、绘制时使用该matrix，且clipRect控制显示区域（这个区域也很简单，原图的第一块到最后一块），最好就是绘制bitmap了。

阴影这里大家可以换个明亮点的图片去看看~~


好了，由于篇幅原因，剩下的内容将在下一篇继续完成，下一篇将展示如何将简单的图片的折叠，转化为对一个布局内所有控件的折叠效果，以及引入手势、

和DrawerLayout等结合应用到侧滑中去。

对于类似这种效果的，一定要拿出稿纸笔去画一画，否则很难弄明白。


源码：下载

群号：429757068

微信公众号请扫描（第一时间通知博客、视频等通知）：

万剑
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AndroidFoldingLayout折叠布局原理及实现（一）
02-26
1、Matrix的setPolyToPoly使用2、在图片上使用渐变和阴影3、初步的FoldingLayout的实现，完成图片的折叠显示（可控制折叠次数、包含阴影的绘制）4、引入手势，手指可以可以FoldingLayout的折叠5、结合DrawerLayout...
Android FoldingLayout 折叠布局 原理及实现（二）
2301_82243733的博客
04-28 729
我们选择继承FoldLayout，重写其onTouchEvent，然后通过mScrollGestureDetector获取移动的距离，最终和width做比值得到我们的factor，然后调用setFactor进行改变。对于SlidingPaneLayout的使用，应该没什么问题吧，就是把布局文件的根布局设置为SlidingPaneLayout，然后里面放两个子布局，一个代表侧滑菜单，一个代表内容区域。至此我们完成了炫酷的效果，但是我们还需要应用到具体的案例上，否则就是特技，有必要duang一下。
Android FoldingLayout 折叠布局 原理及实现（二）(1)
2301_82243733的博客
04-28 605
对于SlidingPaneLayout的使用，应该没什么问题吧，就是把布局文件的根布局设置为SlidingPaneLayout，然后里面放两个子布局，一个代表侧滑菜单，一个代表内容区域。DraweLayout的侧滑菜单，比如我们拉出来50%，那么正常来说显示的时侧滑布局右侧的50%，但是这个0.5如果设置给我们的factor，它会把布局缩小到50%且在左边。让其最后合并位置为右侧。2、让我们的折叠，收缩到最终的位置可以控制，我们现在统统往最坐标收缩，如果可以设置为最右边，那么本例就没有问题了。
AndroidFoldingLayout折叠布局原理及实现（二）
03-03
在上一篇AndroidFoldingLayout折叠布局原理及实现（一）我们实现了下面的1，2，3。1、Matrix的setPolyToPoly使用2、在图片上使用渐变和阴影3、初步的FoldingLayout的实现，完成图片的折叠显示（可控制折叠次数、包含...
Android中FoldingLayout折叠布局的用法及实战全攻略
09-02
主要介绍了Android中FoldingLayout折叠布局的用法及实例,通过FoldingLayout我们可以制作出炫酷的菜单折叠效果,文中的例子讲解得非常详细,需要的朋友可以参考下
android高斯模糊填充imageview背景
cf8833的博客
05-21 217
说明：最近碰到一个需求，安卓app显示在线的url图片，然后imageview没占满的部分，使用该图片的模糊背景填充。
Android 屏保开关
最新发布
weixin_44021334的博客
05-23 321
设置-显示-屏保，
安卓部署ffmpeg全平台so并实现命令行调用
codeofcc的博客
05-17 1108
前面的章节实现了ffmpeg全平台so的生成，接下来的步骤就是部署以及使用了，部署so还是比较简单的，用gradle和cmake都可以部署，部署好了就可以直接使用了，如果需要c++进行封装一层，则需要链接，对cmake熟悉的话链接也是比较简单的。以上就是今天讲述的内容，ffmpeg的so部署还是比较容易的，但是命令行的调用会麻烦一些，尤其是要解决ffmpeg退出问题，在c++中比较好解决，java理论上也比较好实现，如果在dart中则会比较麻烦，因为dart的方法通常不能跨线程调用，多线程的情况会出问题。
Android正向开发实现客户端证书认证
dafan0的博客
05-18 399
如果第三方模块被混淆，那hook方式均不能生效。这时就需要根据系统包去定位校验的函数，因此需要对安卓开发者是如何实现客户端证书校验的有一定了解，接下来就介绍这部分内容。开发者实现客户端证书校验的本质是：证书/密钥 + 代码。在形式上有：公钥校验、证书校验和Host（主机）校验。
Android 11 触摸小圆点显示流程
littleyards的博客
05-21 569
当SHOW_TOUCHES 这个key的值有改变时，调用updateShowTouchesFromSettings方法，在updateShowTouchesFromSettings方法中，是调用nativeSetShowTouches这个native方法，直接来看下这个方法。小圆点的图片资源已经被加载，并将其保存在相应的变量中了，接下来就需要将其显示出来了。在开发者选项中，打开 “显示点按操作反馈” 开关，当我们在触摸屏幕时，会显示一个小圆点，来分析下小圆点的显示流程。
PHP反射API与接口的动态分析
APItesterCris的博客
05-22 252
PHP的反射（Reflection）API 提供了一种在运行时获取类和对象信息的能力，包括类的方法、属性、接口等。这对于动态分析、构建IDE的自动完成功能、或者进行复杂的元编程非常有用。以下是如何使用PHP反射API进行动态分析的示例代码。
Android Audio基础——AudioFlinger回放录制线程（七）
小旭的专栏
05-20 234
PlaybackThread 和 RecordThread 的基类。录制线程类，由 ThreadBase 派生。回放线程基类，同由 ThreadBase 派生。混音回放线程类，由 PlaybackThread 派生，负责处理标识为 AUDIO_OUTPUT_FLAG_PRIMARY、AUDIO_OUTPUT_FLAG_FAST、AUDIO_OUTPUT_FLAG_DEEP_BUFFER 的音频流，MixerThread 可以把多个音轨的数据混音后再输出。
android radiongroup应用举例
xie__jin__cheng的博客
05-18 219
android radiongroup应用举例
Android9禁止某个app启动
qq_44203816的博客
05-21 150
条件成立时 --------> return ActivityManager.START_CANCELED
Android SDK的安装和配置
Rverdoser的博客
05-17 220
Android SDK的安装和配置是开发Android应用的重要步骤，下面我为你详细介绍一下这个过程：安装Android SDK1. 打开官网：首先，你需要访问Android SDK的官方网站，找到SDK工具的下载链接。2. 下载SDK：在官网上，选择适合你操作系统的SDK版本进行下载。通常，你可以选择ZIP压缩包或EXE安装包，两者在实际使用上没有太大区别。3. 解压并存放：下载完成后，将SDK文件解压到你想要存放的目录。注意，存放路径最好不要包含中文或特殊字符4. 运行安装程序：如果你下载的是EXE安装
android GridLayout 布局详解，并举例
xie__jin__cheng的博客
05-18 409
android GridLayout 布局详解，并举例
安卓高级控件（下拉框、列表类视图、翻页类视图、碎片Fragment）
weixin_42369301的博客
05-19 765
介绍安卓下拉框、列表类视图、翻页类视图、碎片Fragment的日常用法
android studio实现按钮控制布局的折叠
05-21
要实现按钮控制布局的折叠，可以使用 Android 中的 `ConstraintLayout` 和 `ConstraintSet`。 首先，在 XML 布局文件中，将需要折叠的布局放在一个 `ConstraintLayout` 中，并添加一个按钮，用于控制折叠。例如： ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值