Android 上传头像(文件)到服务器

深碍√TFBOYSˉ_ 2022-07-18 05:19 390阅读 0赞

现在很多app都用到了头像的功能，我的项目中也用到了。
头像上传分几步：
1.获取头像
2.剪裁头像
3.文件上传
4.服务器的接受保存
首先第一步，无非就是两种方式
1，拍照
2，相册选择
之前的博客中有现到，不重复，链接：
http://blog.csdn.net/w18756901575/article/details/52087242
http://blog.csdn.net/w18756901575/article/details/52085157
第二步，裁剪头像
这一步我用的时鸿洋大神的东西，是个自定的控件，不过我对其中代码进行了一点点的修改，使之更适合自己的项目，里面原理就是监听onTouchEvent来对缩放，双击事件进行相应的处理，裁剪就是根据大小，创建一个新的bitmap，当然说起来挺简单，如果没有别人的代码可以借鉴参考，估计有的搞了，在此谢谢鸿洋大神，下面是鸿洋大神的博客链接：
http://blog.csdn.net/lmj623565791/article/details/39761281
裁剪图片好像还可以调用Android自带的裁剪功能，不过我没用过，
第三步，上传图片，
上传图片不过也就是上传文件，可以将文件转化为byte数组然后进行base64转码后进行上传，在服务器接收到后，将string解码成byte数组，然后在转化为文件。
当然上传的方法有很多，肯定不止这一种 ，因为项目的Android和web接口都是我写的所已我就这样写啦…谁让自己的web技术有限呢，原来写Android的时候一直说调用接口接口，原来自己写了才知道，其实就是一个配置好servlet的java文件.⊙﹏⊙||
写接口和写Android差不过嘛，都是用Java写的，本家嘛
对了文件上传的时候如果从本地读取，会需要读取sd卡的权限，我在6.0的模拟器上测试的时候，一直有问题，找了半天才发现是因为，没有申请权限，，，设立的权限不仅仅时AndroidManifest里面的权限声明，在6.0的系统中需要用代码弹出对话框向用户申请..
贴下请求代码

  1. /**
  2.      * 请求权限
  3.      */
  4.     public void getUserPar() {
  5. //        Log.d("测试--授权信息", ContextCompat.checkSelfPermission(this,
  6. //                Manifest.permission.WRITE_EXTERNAL_STORAGE) + "");
  7. //        Log.d("测试--已授权", PackageManager.PERMISSION_GRANTED + "");
  8. //        Log.d("测试--未授权", PackageManager.PERMISSION_DENIED + "");
  9.         if (ContextCompat.checkSelfPermission(this,
  10.                 Manifest.permission.WRITE_EXTERNAL_STORAGE)
  11.                 == PackageManager.PERMISSION_GRANTED && ContextCompat.checkSelfPermission(this,
  12.                 Manifest.permission.READ_EXTERNAL_STORAGE)
  13.                 == PackageManager.PERMISSION_GRANTED) {
  14.         } else {
  15.             ActivityCompat.requestPermissions(this,
  16.                     new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE, Manifest.permission.READ_EXTERNAL_STORAGE},
  17.                     1);
  18.         }
  19.     }
  21.     @Override
  22.     public void onRequestPermissionsResult(int requestCode, String permissions[], int[] grantResults) {
  23.         switch (requestCode) {
  24.             case 1: {
  25.                 if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
  26.                     L.d("同意");
  27.                 } else {
  28.                     L.d("拒绝");
  29.                 }
  30.                 return;
  31.             }
  32.         }
  33.     }

还有文件和数组相互转化的代码

  1. /**
  2.      * 将file文件转化为byte数组
  3.      *
  4.      * @param filePath
  5.      * @return
  6.      */
  7.     public static byte[] getBytes(String filePath) {
  8.         byte[] buffer = null;
  9.         try {
  10.             File file = new File(filePath);
  11.             FileInputStream fis = new FileInputStream(file);
  12.             ByteArrayOutputStream bos = new ByteArrayOutputStream(1000);
  13.             byte[] b = new byte[1000];
  14.             int n;
  15.             while ((n = fis.read(b)) != -1) {
  16.                 bos.write(b, 0, n);
  17.             }
  18.             fis.close();
  19.             bos.close();
  20.             buffer = bos.toByteArray();
  21.         } catch (FileNotFoundException e) {
  22.             e.printStackTrace();
  23.         } catch (IOException e) {
  24.             e.printStackTrace();
  25.         }
  26.         return buffer;
  27.     }
  29.     /**
  30.      * 将byte数组转化为file文件
  31.      *
  32.      * @param bfile
  33.      * @param filePath
  34.      * @param fileName
  35.      */
  36.     public static void getFile(byte[] bfile, String filePath, String fileName) {
  37.         BufferedOutputStream bos = null;
  38.         FileOutputStream fos = null;
  39.         File file = null;
  40.         try {
  41.             File dir = new File(filePath);
  42.             if (!dir.exists() && dir.isDirectory()) {
  43.    // 判断文件目录是否存在
  44.                 dir.mkdirs();
  45.             }
  46.             file = new File(filePath + "\\" + fileName);
  47.             fos = new FileOutputStream(file);
  48.             bos = new BufferedOutputStream(fos);
  49.             bos.write(bfile);
  50.             bos.flush();
  51.         } catch (Exception e) {
  52.             e.printStackTrace();
  53.         } finally {
  54.             if (bos != null) {
  55.                 try {
  56.                     bos.close();
  57.                 } catch (IOException e1) {
  58.                     e1.printStackTrace();
  59.                 }
  60.             }
  61.             if (fos != null) {
  62.                 try {
  63.                     fos.close();
  64.                 } catch (IOException e1) {
  65.                     e1.printStackTrace();
  66.                 }
  67.             }
  68.         }
  69.     }

还有base64转码的：

http://blog.csdn.net/w18756901575/article/details/51073847

嗯，好像只有这些，，没了，，end

对了还有圆角，模糊，图片压缩,,,一起放上去吧
20160906163003722

圆形图片效果：

  1. import android.content.Context;
  2. import android.content.res.TypedArray;
  3. import android.graphics.Bitmap;
  4. import android.graphics.Bitmap.Config;
  5. import android.graphics.BitmapFactory;
  6. import android.graphics.Canvas;
  7. import android.graphics.Paint;
  8. import android.graphics.PorterDuff;
  9. import android.graphics.PorterDuffXfermode;
  10. import android.graphics.RectF;
  11. import android.util.AttributeSet;
  12. import android.util.TypedValue;
  13. import android.widget.ImageView;
  15. import com.yesun.league.R;
  16. import com.yesun.league.code.utils.DimensUtils;
  19. /**
  20.  * 自定义View，实现圆角，圆形等效果
  21.  *
  22.  * @author zhy
  23.  */
  24. public class CustomImageView extends ImageView {
  27.     /**
  28.      * TYPE_CIRCLE / TYPE_ROUND
  29.      */
  30.     private int type;
  31.     private static final int TYPE_CIRCLE = 0;
  32.     private static final int TYPE_ROUND = 1;
  34.     /**
  35.      * 图片
  36.      */
  37.     private Bitmap mSrc;
  39.     /**
  40.      * 圆角的大小
  41.      */
  42.     private int mRadius;
  44.     /**
  45.      * 控件的宽度
  46.      */
  47.     private int mWidth;
  48.     /**
  49.      * 控件的高度
  50.      */
  51.     private int mHeight;
  54.     public CustomImageView(Context context, AttributeSet attrs) {
  55.         this(context, attrs, 0);
  56.     }
  58.     public CustomImageView(Context context) {
  59.         this(context, null);
  60.     }
  62.     /**
  63.      * 初始化一些自定义的参数
  64.      *
  65.      * @param context
  66.      * @param attrs
  67.      * @param defStyle
  68.      */
  69.     public CustomImageView(Context context, AttributeSet attrs, int defStyle) {
  70.         super(context, attrs, defStyle);
  73.         TypedArray a = context.getTheme().obtainStyledAttributes(attrs,
  74.                 R.styleable.CustomImageView, defStyle, 0);
  76.         int n = a.getIndexCount();
  77.         for (int i = 0; i < n; i++) {
  78.             int attr = a.getIndex(i);
  79.             switch (attr) {
  80.                 case R.styleable.CustomImageView_src:
  81.                     mSrc = BitmapFactory.decodeResource(getResources(),
  82.                             a.getResourceId(attr, 0));
  83.                     break;
  84.                 case R.styleable.CustomImageView_type:
  85.                     type = a.getInt(attr, 0);// 默认为Circle
  86.                     break;
  87.                 case R.styleable.CustomImageView_borderRadius:
  88.                     mRadius = a.getDimensionPixelSize(attr, (int) TypedValue
  89.                             .applyDimension(TypedValue.COMPLEX_UNIT_DIP, 10f,
  90.                                     getResources().getDisplayMetrics()));// 默认为10DP
  91.                     break;
  92.             }
  93.         }
  95.         a.recycle();
  96.     }
  98.     @Override
  99.     public void setImageBitmap(Bitmap bm) {
  100.         super.setImageBitmap(bm);
  101.         this.mSrc = bm;
  102.         postInvalidate();
  103.     }
  105.     /**
  106.      * 计算控件的高度和宽度
  107.      */
  108.     @Override
  109.     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
  110.         super.onMeasure(widthMeasureSpec, heightMeasureSpec);
  111.         /**
  112.          * 设置宽度
  113.          */
  114.         int specMode = MeasureSpec.getMode(widthMeasureSpec);
  115.         int specSize = MeasureSpec.getSize(widthMeasureSpec);
  117.         if (specMode == MeasureSpec.EXACTLY)// match_parent , accurate
  118.         {
  119.             mWidth = specSize;
  120.         } else {
  121.             // 由图片决定的宽
  122.             int desireByImg = getPaddingLeft() + getPaddingRight()
  123.                     + mSrc.getWidth();
  124.             if (specMode == MeasureSpec.AT_MOST) {
  125.     //wrap_content
  126.                 mWidth = Math.min(desireByImg, specSize);
  127.             } else
  129.                 mWidth = desireByImg;
  130.         }
  132.         /***
  133.          * 设置高度
  134.          */
  136.         specMode = MeasureSpec.getMode(heightMeasureSpec);
  137.         specSize = MeasureSpec.getSize(heightMeasureSpec);
  138.         if (specMode == MeasureSpec.EXACTLY) {
  139.     // match_parent , accurate
  140.             mHeight = specSize;
  141.         } else {
  142.             int desire = getPaddingTop() + getPaddingBottom()
  143.                     + mSrc.getHeight();
  145.             if (specMode == MeasureSpec.AT_MOST) {
  146.     // wrap_content
  147.                 mHeight = Math.min(desire, specSize);
  148.             } else
  149.                 mHeight = desire;
  150.         }
  152.         setMeasuredDimension(mWidth, mHeight);
  154.     }
  156.     /**
  157.      * 绘制
  158.      */
  159.     @Override
  160.     protected void onDraw(Canvas canvas) {
  161.         switch (type) {
  162.             // 如果是TYPE_CIRCLE绘制圆形
  163.             case TYPE_CIRCLE:
  164.                 int min = Math.min(mWidth, mHeight);
  165.                 /**
  166.                  * 长度如果不一致，按小的值进行压缩
  167.                  */
  168.                 mSrc = Bitmap.createScaledBitmap(mSrc, min, min, false);
  169.                 canvas.drawBitmap(createCircleImage(mSrc, min), 0, 0, null);
  171.                 //下面是绘制圆环的，不喜欢的可以不要
  172.                 Paint paint=new Paint();
  173.                 int centre = getWidth()/2; //获取圆心的x坐标
  174.                 int radius = (int) (centre - DimensUtils.dp2px(getContext(),3)/2); //圆环的半径
  175.                 paint.setColor(0x88ffffff); //设置圆环的颜色
  176.                 paint.setStyle(Paint.Style.STROKE); //设置空心
  177.                 paint.setStrokeWidth(DimensUtils.dp2px(getContext(),3)); //设置圆环的宽度
  178.                 paint.setAntiAlias(true);  //消除锯齿
  179.                 canvas.drawCircle(centre, centre, radius, paint); //画出圆环
  180.                 break;
  181.             case TYPE_ROUND:
  183.                 mSrc = Bitmap.createScaledBitmap(mSrc, mWidth, mHeight, false);
  184.                 canvas.drawBitmap(createRoundConerImage(mSrc), 0, 0, null);
  185.                 break;
  186.         }
  188.     }
  190.     /**
  191.      * 根据原图和变长绘制圆形图片
  192.      *
  193.      * @param source
  194.      * @param min
  195.      * @return
  196.      */
  197.     private Bitmap createCircleImage(Bitmap source, int min) {
  198.         final Paint paint = new Paint();
  199.         paint.setAntiAlias(true);
  200.         Bitmap target = Bitmap.createBitmap(min, min, Config.ARGB_8888);
  201.         /**
  202.          * 产生一个同样大小的画布
  203.          */
  204.         Canvas canvas = new Canvas(target);
  206.         /**
  207.          * 首先绘制圆形
  208.          */
  209.         canvas.drawCircle(min / 2, min / 2, min / 2, paint);
  210.         /**
  211.          * 使用SRC_IN，参考上面的说明
  212.          */
  213.         paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));//相交部分取后绘制上去的
  214. //        paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_IN));//相交部分取
  215.         /**
  216.          * 绘制图片
  217.          */
  218.         canvas.drawBitmap(source, 0, 0, paint);
  219.         return target;
  220.     }
  222.     /**
  223.      * 根据原图添加圆角
  224.      *
  225.      * @param source
  226.      * @return
  227.      */
  228.     private Bitmap createRoundConerImage(Bitmap source) {
  229.         final Paint paint = new Paint();
  230.         paint.setAntiAlias(true);
  231.         Bitmap target = Bitmap.createBitmap(mWidth, mHeight, Config.ARGB_8888);
  232.         Canvas canvas = new Canvas(target);
  233.         RectF rect = new RectF(0, 0, source.getWidth(), source.getHeight());
  234.         canvas.drawRoundRect(rect, mRadius, mRadius, paint);
  235.         paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
  236.         canvas.drawBitmap(source, 0, 0, paint);
  237.         return target;
  238.     }
  239. }

压缩，模糊都在这个工具类中，自己看吧：

  1. import android.annotation.TargetApi;
  2. import android.content.Context;
  3. import android.content.res.Resources;
  4. import android.graphics.Bitmap;
  5. import android.graphics.BitmapFactory;
  6. import android.graphics.Canvas;
  7. import android.graphics.PixelFormat;
  8. import android.graphics.drawable.BitmapDrawable;
  9. import android.graphics.drawable.Drawable;
  10. import android.os.Build;
  11. import android.renderscript.Allocation;
  12. import android.renderscript.Element;
  13. import android.renderscript.RenderScript;
  14. import android.renderscript.ScriptIntrinsicBlur;
  16. import java.io.ByteArrayInputStream;
  17. import java.io.ByteArrayOutputStream;
  18. import java.io.FileInputStream;
  19. import java.io.IOException;
  21. /**
  22.  * Created by wkk on 2016/8/23.
  23.  * <p>
  24.  * 工具类
  25.  */
  26. public class BitmapUtils {
  29.     //   compile 'com.yolanda.nohttp:nohttp:1.0.4'
  31.     /**
  32.      * 从本地读取图片
  33.      *
  34.      * @param path
  35.      * @return
  36.      */
  37.     public static Bitmap getBitmapForPath(String path) {
  38.         try {
  39.             FileInputStream in = new FileInputStream(path);
  40.             Bitmap bitmap = BitmapFactory.decodeStream(in);
  41.             in.close();
  42.             return bitmap;
  43.         } catch (Exception e) {
  44.         }
  45.         return null;
  46.     }
  49.     /**
  50.      * 获取资源文件中的图片
  51.      *
  52.      * @param context
  53.      * @param resourcesId
  54.      * @return
  55.      */
  56.     public static Drawable getDrawableFormResources(Context context, int resourcesId) {
  57.         Resources resources = context.getResources();
  58.         return new BitmapDrawable(resources, BitmapFactory.decodeResource(resources, resourcesId));
  59.     }
  61.     /**
  62.      * 从资源文件中获取bitmap对象
  63.      *
  64.      * @param context
  65.      * @param resourcesId
  66.      * @return
  67.      */
  68.     public static Bitmap getBitmapFromResources(Context context, int resourcesId) {
  69.         return BitmapFactory.decodeResource(context.getResources(), resourcesId);
  70.     }
  72.     /**
  73.      * bitmap转byte数组
  74.      *
  75.      * @param bitmap
  76.      * @return
  77.      */
  78.     public static byte[] getBitmapbyte(Bitmap bitmap) {
  79.         ByteArrayOutputStream baos = new ByteArrayOutputStream();
  80.         bitmap.compress(Bitmap.CompressFormat.PNG, 100, baos);
  81.         byte[] datas = baos.toByteArray();
  82.         try {
  83.             baos.flush();
  84.             baos.close();
  85.         } catch (IOException e) {
  86.             e.printStackTrace();
  87.         }
  88.         return datas;
  89.     }
  91.     /**
  92.      * byte转bitmap数组
  93.      *
  94.      * @param b
  95.      * @return
  96.      */
  97.     public static Bitmap getBitmaoFrombyte(byte[] b) {
  98.         return BitmapFactory.decodeByteArray(b, 0, b.length);
  99.     }
  102.     /**
  103.      * 压缩1
  104.      *
  105.      * @param srcPath
  106.      * @return
  107.      */
  108.     public static Bitmap getimage(String srcPath) {
  109.         BitmapFactory.Options newOpts = new BitmapFactory.Options();
  110.         //开始读入图片，此时把options.inJustDecodeBounds 设回true了
  111.         newOpts.inJustDecodeBounds = true;
  112.         Bitmap bitmap = BitmapFactory.decodeFile(srcPath, newOpts);//此时返回bm为空
  114.         newOpts.inJustDecodeBounds = false;
  115.         int w = newOpts.outWidth;
  116.         int h = newOpts.outHeight;
  117.         //现在主流手机比较多是800*480分辨率，所以高和宽我们设置为
  118.         float hh = 800f;//这里设置高度为800f
  119.         float ww = 480f;//这里设置宽度为480f
  120.         //缩放比。由于是固定比例缩放，只用高或者宽其中一个数据进行计算即可
  121.         int be = 1;//be=1表示不缩放
  122.         if (w > h && w > ww) {
  123.     //如果宽度大的话根据宽度固定大小缩放
  124.             be = (int) (newOpts.outWidth / ww);
  125.         } else if (w < h && h > hh) {
  126.     //如果高度高的话根据宽度固定大小缩放
  127.             be = (int) (newOpts.outHeight / hh);
  128.         }
  129.         if (be <= 0)
  130.             be = 1;
  131.         newOpts.inSampleSize = be;//设置缩放比例
  132.         //重新读入图片，注意此时已经把options.inJustDecodeBounds 设回false了
  133.         bitmap = BitmapFactory.decodeFile(srcPath, newOpts);
  134.         return compressImage(bitmap);//压缩好比例大小后再进行质量压缩
  135.     }
  138.     /**
  139.      * 压缩2
  140.      *
  141.      * @param image
  142.      * @return
  143.      */
  144.     public static Bitmap comp(Bitmap image) {
  146.         ByteArrayOutputStream baos = new ByteArrayOutputStream();
  147.         image.compress(Bitmap.CompressFormat.JPEG, 100, baos);
  148.         if (baos.toByteArray().length / 1024 > 1024) {
  149.     //判断如果图片大于1M,进行压缩避免在生成图片（BitmapFactory.decodeStream）时溢出
  150.             baos.reset();//重置baos即清空baos
  151.             image.compress(Bitmap.CompressFormat.JPEG, 50, baos);//这里压缩50%，把压缩后的数据存放到baos中
  152.         }
  153.         ByteArrayInputStream isBm = new ByteArrayInputStream(baos.toByteArray());
  154.         BitmapFactory.Options newOpts = new BitmapFactory.Options();
  155.         //开始读入图片，此时把options.inJustDecodeBounds 设回true了
  156.         newOpts.inJustDecodeBounds = true;
  157.         Bitmap bitmap = BitmapFactory.decodeStream(isBm, null, newOpts);
  158.         newOpts.inJustDecodeBounds = false;
  159.         int w = newOpts.outWidth;
  160.         int h = newOpts.outHeight;
  161.         //现在主流手机比较多是800*480分辨率，所以高和宽我们设置为
  162.         float hh = 800f;//这里设置高度为800f
  163.         float ww = 480f;//这里设置宽度为480f
  164.         //缩放比。由于是固定比例缩放，只用高或者宽其中一个数据进行计算即可
  165.         int be = 1;//be=1表示不缩放
  166.         if (w > h && w > ww) {
  167.     //如果宽度大的话根据宽度固定大小缩放
  168.             be = (int) (newOpts.outWidth / ww);
  169.         } else if (w < h && h > hh) {
  170.     //如果高度高的话根据宽度固定大小缩放
  171.             be = (int) (newOpts.outHeight / hh);
  172.         }
  173.         if (be <= 0)
  174.             be = 1;
  175.         newOpts.inSampleSize = be;//设置缩放比例
  176.         newOpts.inPreferredConfig = Bitmap.Config.RGB_565;//降低图片从ARGB888到RGB565
  177.         //重新读入图片，注意此时已经把options.inJustDecodeBounds 设回false了
  178.         isBm = new ByteArrayInputStream(baos.toByteArray());
  179.         bitmap = BitmapFactory.decodeStream(isBm, null, newOpts);
  180.         return compressImage(bitmap);//压缩好比例大小后再进行质量压缩
  181.     }
  183.     /**
  184.      * 质量压缩
  185.      *
  186.      * @param image
  187.      * @return
  188.      */
  189.     public static Bitmap compressImage(Bitmap image) {
  190.         ByteArrayOutputStream baos = new ByteArrayOutputStream();
  191.         image.compress(Bitmap.CompressFormat.JPEG, 100, baos);//质量压缩方法，这里100表示不压缩，把压缩后的数据存放到baos中
  192.         int options = 100;
  193.         while (baos.toByteArray().length / 1024 > 100) {    //循环判断如果压缩后图片是否大于100kb,大于继续压缩
  194.             baos.reset();//重置baos即清空baos
  195.             options -= 10;//每次都减少10
  196.             image.compress(Bitmap.CompressFormat.JPEG, options, baos);//这里压缩options%，把压缩后的数据存放到baos中
  198.         }
  199.         ByteArrayInputStream isBm = new ByteArrayInputStream(baos.toByteArray());//把压缩后的数据baos存放到ByteArrayInputStream中
  200.         Bitmap bitmap = BitmapFactory.decodeStream(isBm, null, null);//把ByteArrayInputStream数据生成图片
  201.         return bitmap;
  202.     }
  204.     /**
  205.      * 获取图片大小
  206.      *
  207.      * @param bitmap
  208.      * @return
  209.      */
  210.     public static long getBitmapsize(Bitmap bitmap) {
  211.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR1) {
  212.             return bitmap.getByteCount();
  213.         }
  214.         return bitmap.getRowBytes() * bitmap.getHeight();
  215.     }
  218.     /**
  219.      * 对图片进行模糊处理
  220.      *
  221.      * @param bitmap
  222.      * @param context
  223.      * @return
  224.      */
  225.     @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
  226.     public static Bitmap blurBitmap(Bitmap bitmap, Context context) {
  227.         Bitmap outBitmap = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), Bitmap.Config.ARGB_8888);
  228.         RenderScript rs = RenderScript.create(context.getApplicationContext());
  229.         ScriptIntrinsicBlur blurScript = ScriptIntrinsicBlur.create(rs, Element.U8_4(rs));
  230.         Allocation allIn = Allocation.createFromBitmap(rs, bitmap);
  231.         Allocation allOut = Allocation.createFromBitmap(rs, outBitmap);
  232.         blurScript.setRadius(25f);
  233.         blurScript.setInput(allIn);
  234.         blurScript.forEach(allOut);
  235.         allOut.copyTo(outBitmap);
  236.         bitmap.recycle();
  237.         rs.destroy();
  238.         return outBitmap;
  239.     }
  242.     public static Bitmap drawableToBitmap(Drawable drawable) {
  243.         Bitmap bitmap = Bitmap.createBitmap(
  244.                 drawable.getIntrinsicWidth(),
  245.                 drawable.getIntrinsicHeight(),
  246.                 drawable.getOpacity() != PixelFormat.OPAQUE ? Bitmap.Config.ARGB_8888 : Bitmap.Config.RGB_565);
  247.         Canvas canvas = new Canvas(bitmap);
  248.         //canvas.setBitmap(bitmap);
  249.         drawable.setBounds(0, 0, drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight());
  250.         drawable.draw(canvas);
  251.         return bitmap;
  252.     }
  254.     /**
  255.      * 水平方向模糊度
  256.      */
  257.     private static float hRadius = 10;
  258.     /**
  259.      * 竖直方向模糊度
  260.      */
  261.     private static float vRadius = 10;
  262.     /**
  263.      * 模糊迭代度
  264.      */
  265.     private static int iterations = 7;
  266.     private static float a = 1.3f;
  268.     /**
  269.      * 模糊图片
  270.      * @param bmp
  271.      * @return
  272.      */
  273.     public static Drawable BoxBlurFilter(Bitmap bmp) {
  274.         hRadius = hRadius * a;
  275.         vRadius = vRadius * a;
  276.         iterations = (int) (iterations * a);
  279.         int width = bmp.getWidth();
  280.         int height = bmp.getHeight();
  281.         int[] inPixels = new int[width * height];
  282.         int[] outPixels = new int[width * height];
  283.         Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
  284.         bmp.getPixels(inPixels, 0, width, 0, 0, width, height);
  285.         for (int i = 0; i < iterations; i++) {
  286.             blur(inPixels,
  287.                     outPixels, width, height, hRadius);
  288.             blur(outPixels,
  289.                     inPixels, height, width, vRadius);
  290.         }
  291.         blurFractional(inPixels,
  292.                 outPixels, width, height, hRadius);
  293.         blurFractional(outPixels,
  294.                 inPixels, height, width, vRadius);
  295.         bitmap.setPixels(inPixels,
  296.                 0,
  297.                 width, 0,
  298.                 0,
  299.                 width, height);
  300.         Drawable drawable = new BitmapDrawable(bitmap);
  301.         return drawable;
  302.     }
  304.     public static void blur(int[] in, int[] out, int width, int height, float radius) {
  305.         int widthMinus1 = width - 1;
  306.         int r = (int) radius;
  307.         int tableSize = 2 * r + 1;
  308.         int divide[] = new int[256 * tableSize];
  309.         for (int i = 0; i < 256 * tableSize; i++)
  310.             divide[i] = i / tableSize;
  311.         int inIndex = 0;
  312.         for (int y = 0; y < height; y++) {
  313.             int outIndex = y;
  314.             int ta = 0, tr = 0, tg = 0, tb = 0;
  315.             for (int i = -r; i <= r; i++) {
  316.                 int rgb = in[inIndex + clamp(i, 0, width - 1)];
  317.                 ta += (rgb >> 24) & 0xff;
  318.                 tr += (rgb >> 16) & 0xff;
  319.                 tg += (rgb >> 8) & 0xff;
  320.                 tb += rgb & 0xff;
  321.             }
  322.             for (int x = 0; x < width; x++) {
  323.                 out[outIndex] = (divide[ta] << 24) | (divide[tr] << 16) | (divide[tg] << 8)
  324.                         | divide[tb];
  325.                 int i1 = x + r + 1;
  326.                 if (i1 > widthMinus1)
  327.                     i1 = widthMinus1;
  328.                 int i2 = x - r;
  329.                 if (i2 < 0)
  330.                     i2 = 0;
  331.                 int rgb1 = in[inIndex + i1];
  332.                 int rgb2 = in[inIndex + i2];
  333.                 ta += ((rgb1 >> 24) & 0xff) - ((rgb2 >> 24) & 0xff);
  334.                 tr += ((rgb1 & 0xff0000) - (rgb2 & 0xff0000)) >> 16;
  335.                 tg += ((rgb1 & 0xff00) - (rgb2 & 0xff00)) >> 8;
  336.                 tb += (rgb1 & 0xff) - (rgb2 & 0xff);
  337.                 outIndex += height;
  338.             }
  339.             inIndex += width;
  340.         }
  341.     }
  343.     public static void blurFractional(int[] in, int[] out, int width, int height, float radius) {
  344.         radius -= (int) radius;
  345.         float f = 1.0f / (1 + 2 * radius);
  346.         int inIndex = 0;
  347.         for (int y = 0; y < height; y++) {
  348.             int outIndex = y;
  349.             out[outIndex] = in[0];
  350.             outIndex += height;
  351.             for (int x = 1; x < width - 1; x++) {
  352.                 int i = inIndex + x;
  353.                 int rgb1 = in[i - 1];
  354.                 int rgb2 = in[i];
  355.                 int rgb3 = in[i + 1];
  356.                 int a1 = (rgb1 >> 24)
  357.                         & 0xff;
  358.                 int r1
  359.                         = (rgb1 >> 16)
  360.                         & 0xff;
  361.                 int g1
  362.                         = (rgb1 >> 8)
  363.                         & 0xff;
  364.                 int b1
  365.                         = rgb1 & 0xff;
  366.                 int a2
  367.                         = (rgb2 >> 24)
  368.                         & 0xff;
  369.                 int r2
  370.                         = (rgb2 >> 16)
  371.                         & 0xff;
  372.                 int g2
  373.                         = (rgb2 >> 8)
  374.                         & 0xff;
  375.                 int b2
  376.                         = rgb2 & 0xff;
  377.                 int a3
  378.                         = (rgb3 >> 24)
  379.                         & 0xff;
  380.                 int r3
  381.                         = (rgb3 >> 16)
  382.                         & 0xff;
  383.                 int g3
  384.                         = (rgb3 >> 8)
  385.                         & 0xff;
  386.                 int b3
  387.                         = rgb3 & 0xff;
  388.                 a1
  389.                         = a2 + (int)
  390.                         ((a1 + a3) * radius);
  391.                 r1
  392.                         = r2 + (int)
  393.                         ((r1 + r3) * radius);
  394.                 g1
  395.                         = g2 + (int)
  396.                         ((g1 + g3) * radius);
  397.                 b1
  398.                         = b2 + (int)
  399.                         ((b1 + b3) * radius);
  400.                 a1
  401.                         *= f;
  402.                 r1
  403.                         *= f;
  404.                 g1
  405.                         *= f;
  406.                 b1
  407.                         *= f;
  408.                 out[outIndex]
  409.                         = (a1 << 24)
  410.                         | (r1 << 16)
  411.                         | (g1 << 8)
  412.                         | b1;
  413.                 outIndex
  414.                         += height;
  415.             }
  416.             out[outIndex]
  417.                     = in[width - 1];
  418.             inIndex
  419.                     += width;
  420.         }
  421.     }
  423.     public static int clamp(int x,
  424.                             int a,
  425.                             int b) {
  426.         return (x
  427.                 < a) ? a : (x > b) ? b : x;
  428.     }
  431. }

嗯哼，，真的没了，，end

2017/10/12 08:49
关于上传文件到服务器的.两种思路或者是方法.
1.将文件转成base64编码放在字段里面,像正常的http交互一样去访问服务器上传
2.将文件写入流中上传

发表评论

表情：
评论列表 （有 0 条评论，390人围观）

还没有评论，来说两句吧...

相关阅读