Android实用工具之三—图片处理工具

最新推荐文章于 2020-08-12 11:40:50 发布
最新推荐文章于 2020-08-12 11:40:50 发布
阅读量547 收藏 1
点赞数
分类专栏： Android 文章标签： android 图片工具类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wuqiqi1992/article/details/50496144
版权 
package net.hyww.utils;

import android.app.Activity;
import android.content.ActivityNotFoundException;
import android.content.Context;
import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Matrix;
import android.media.ExifInterface;
import android.net.Uri;
import android.os.Environment;
import android.provider.MediaStore;
import android.support.v4.app.Fragment;
import android.support.v4.util.LruCache;
import android.text.TextUtils;
import android.widget.Toast;
import com.nostra13.universalimageloader.utils.StorageUtils;
import net.hyww.widget.simplecropimage.CropImage;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @HYWW 图片处理类 2013-10-22
 */
public class PicUtils {
    private static final boolean DBG = true;
    private static final String TAG = PicUtils.class.getSimpleName();

    /**
     * 图片缓存技术的核心类，用于缓存所有下载好的图片，在程序内存达到设定值时会将最少最近使用的图片移除掉。
     */
    public static LruCache<String, Bitmap> mMemoryCache;
    /**
     * 从系统相册获取相片requestCode
     */
    public static final int FORM_PHOTOS_CODE = 1;
    /**
     * 从系统相机获取相片requestCode
     */
    public static final int FORM_OS_CAMERA_CODE = 2;
    /**
     * 相片裁剪requestCode
     */
    public static final int CROP_PIC_CODE = 3;

    public static final int PICK_PIC_REQUEST_CODE = 4;

    public static final int VERTICAL = 1;
    public static final int HORIZONTAL = 2;

    public static final String[] picType = {"bmp", "dib", "gif", "jfif",
            "jpe", "jpeg", "jpg", "png", "tif", "tiff", "ico"};
    
    public static File getImageFile(Context context,String fileName) {
      File f = null;
      if (!TextUtils.isEmpty(FileUtils.getExternalDir(context)))
         f = new File(fileName);

      if (f!=null&&f.getParentFile()!=null&&!f.getParentFile().exists())
         f.getParentFile().mkdirs();

      if (f!=null&&!f.exists()) {
         try {
            f.createNewFile();
         } catch (IOException e) {
            return null;
         }
      }

      return f;
   }

    public static File getFile(Context context,String fileName) {
        File f = null;
        if (!TextUtils.isEmpty(FileUtils.getExternalDir(context)))
            f = new File(fileName);

        if (f!=null&&f.getParentFile()!=null&&!f.getParentFile().exists())
            f.getParentFile().mkdirs();

        if (f!=null&&!f.exists()) {
            try {
                f.createNewFile();
            } catch (IOException e) {
                return null;
            }
        }

        return f;
    }
    
    public static boolean isPhotoExist(Context context,String fileName) {
       File f = null;
      if (!TextUtils.isEmpty(FileUtils.getExternalDir(context)))
         f = new File(fileName);
        if (f == null){
            return false;
        }
      return f.exists();
    }

    /**
     * 使用相机生成照片
     *
     * @param context
     */
    public static void getPicFromCamera(Activity context,File saveFile) {
        try {
            camerasaveFile=saveFile;
            Intent intent_camera = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
            intent_camera.putExtra(MediaStore.EXTRA_OUTPUT,
                    Uri.fromFile(saveFile));
            context.startActivityForResult(intent_camera, PicUtils.FORM_OS_CAMERA_CODE);
        } catch (Exception e) {
        }
    }

    /**
     * 选择新照相
     *
     * @param context
     */
    public static File camerasaveFile;
    public static void getPicFromCamera(Fragment context,File saveFile) {
        try {
            camerasaveFile=saveFile;
            Intent intent_camera = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
            intent_camera.putExtra(MediaStore.EXTRA_OUTPUT,
                    Uri.fromFile(saveFile));
            context.startActivityForResult(intent_camera, PicUtils.FORM_OS_CAMERA_CODE);
        } catch (Exception e) {
        }
    }

    /**
     * 系统相册选择照片
     *
     * @param context
     */
    public static void getPicFromPhotos(Activity context) {
        try{
            Intent intent = new Intent(Intent.ACTION_GET_CONTENT, null);
            intent.setType("image/*");
//        intent.putExtra("output", Uri.fromFile(new File(new File(
//                IMAGE_FILE_SAVE_PATH), oldPicName)));
            context.startActivityForResult(intent, FORM_PHOTOS_CODE);
        }catch (Exception e){
        }
    }

    /**
     * 系统相册选择照片
     *
     * @param context
     */
    public static void getPicFromPhotos(Fragment context) {
        try{
        Intent intent = new Intent(Intent.ACTION_GET_CONTENT, null);
        intent.setType("image/*");
//        intent.putExtra("output", Uri.fromFile(new File(new File(
//                IMAGE_FILE_SAVE_PATH), oldPicName)));
        context.startActivityForResult(intent, FORM_PHOTOS_CODE);
        }catch (Exception e){
        }
    }

//    /**
//     * 调用系统裁剪图片
//     * @param context
//     * @param oldPicName   原图位置
//     * @param cropPicName  裁剪后位置
//     * @param cropPicWidth 裁剪后宽
//     * @param x            裁剪比例x轴
//     * @param y            裁剪比例y轴
//     */
//    public static void getCropPic(Activity context, String oldPicName,
//                                  String cropPicName, int cropPicWidth, int x, int y) {
//        Intent intent = new Intent("com.android.camera.action.CROP");
//        if (TextUtils.indexOf(oldPicName, "/") >= 0) {
//            intent.setDataAndType(Uri.fromFile(new File(oldPicName)), "image/*");
//        } else {
//            intent.setDataAndType(
//                    Uri.fromFile(new File(IMAGE_FILE_SAVE_PATH, oldPicName)),
//                    "image/*");
//        }
//        intent.putExtra("crop", "true");
//        intent.putExtra("aspectX", x);
//        intent.putExtra("aspectY", y);
//        intent.putExtra("outputX", cropPicWidth);
//        intent.putExtra("outputY", cropPicWidth * y / x);
//        intent.putExtra("outputFormat", Bitmap.CompressFormat.JPEG.toString());
//        intent.putExtra("return-data", true);
        intent.putExtra(CropImage.IMAGE_PATH, path);
//        intent.putExtra("output", Uri.fromFile(new File(new File(
//                IMAGE_FILE_SAVE_PATH), cropPicName)));
//        context.startActivityForResult(intent, CROP_PIC_CODE);
//    }


    private static Intent getCropIntent(Activity activity, String path, int x, int y) {
        Intent intent = new Intent(activity, CropImage.class);

        // tell CropImage activity to look for image to crop
        intent.putExtra(CropImage.IMAGE_PATH, path);
        String outPutPath = null;
        File outFile= OtherUtils.getFileFloder(activity,Environment.DIRECTORY_PICTURES);
        if (outFile==null){
            outPutPath=FileUtils.getExternalDir(activity);
        }else{
            outPutPath = outFile.getAbsolutePath();
        }
        intent.putExtra(CropImage.IMAGE_PATH_OUT_PUT,
                outPutPath + File.separator + getImageSaveName("crop"));

        // allow CropImage activity to rescale image
        intent.putExtra(CropImage.SCALE, true);

        // if the aspect ratio is fixed to ratio 1/1
        intent.putExtra(CropImage.ASPECT_X, x);
        intent.putExtra(CropImage.ASPECT_Y, y);
        intent.putExtra(CropImage.OUTPUT_X, x);
        intent.putExtra(CropImage.OUTPUT_Y, y);
        return intent;
    }

    /**
     * 裁剪图片
     *
     * @param context
     * @param path
     * @param x
     * @param y
     */
    public static void cropImage(Activity context, String path, int x, int y) {
        try {
            context.startActivityForResult(getCropIntent(context, path, x, y), CROP_PIC_CODE);
        } catch (ActivityNotFoundException e) {
            String errorMessage = "Whoops - your device doesn't support the crop action!";

            Toast toast = Toast.makeText(context, errorMessage, Toast.LENGTH_SHORT);
            toast.show();
            e.printStackTrace();
        }
    }

    /**
     * 裁剪图片
     *
     * @param fragment
     * @param path
     * @param x
     * @param y
     */
    public static void cropImage(Fragment fragment, String path, int x, int y) {
        try {
            fragment.startActivityForResult(getCropIntent(fragment.getActivity(), path, x, y), CROP_PIC_CODE);
        } catch (ActivityNotFoundException e) {
            String errorMessage = "Whoops - your device doesn't support the crop action!";

            Toast toast = Toast.makeText(fragment.getActivity(), errorMessage, Toast.LENGTH_SHORT);
            toast.show();
            e.printStackTrace();
        }
    }

    /**
     * 获取图片存储名称
     *
     * @return
     */
    public static String getImageSaveName() {
        return getImageSaveName(null);
    }

    /**
     * 获取图片存储名称
     *
     * @return
     */
    public static String getImageSaveName(String suffix) {
        SimpleDateFormat format = new SimpleDateFormat("yyyyMMdd_HHmmss");// 获取当前时间，进一步转化为字符串
        Date date = new Date(System.currentTimeMillis());
        String str = format.format(date);
        String fileName = null;
        if (TextUtils.isEmpty(suffix)) {
            fileName = str + ".jpg";
        } else {
            fileName = str + "_" + suffix + ".jpg";
        }
        return fileName;
    }

//    /**
//     * 照片压缩 方向调整
//     *
//     * @param src 图片地址
//     */
//    public static Bitmap picRotaingAndCompression(String src) {
//        return picRotaingAndCompression(src, "");
//    }
//
//    public static Bitmap picRotaingAndCompression(String src, String targetSrc) {
//        if (TextUtils.isEmpty(targetSrc)) {
//            targetSrc = src.substring(src.lastIndexOf("/") + 1);
//        }
//        int degree = readPictureDegree(new File(src).getAbsolutePath());
//
//        BitmapFactory.Options newOpts = new BitmapFactory.Options();
//        // 开始读入图片，此时把options.inJustDecodeBounds 设回true了
//        newOpts.inJustDecodeBounds = true;
//        Bitmap bitmap = BitmapFactory.decodeFile(src, newOpts);// 此时返回bm为空
//
//        newOpts.inJustDecodeBounds = false;
//        int w = 0;
//        if (degree == 90 || degree == 270) {
//            w = newOpts.outHeight;
//        } else {
//            w = newOpts.outWidth;
//        }
//        if (w < 0)
//            return null;
//        float ww = 1000f;//
//        // 缩放比。由于是固定比例缩放，只用高或者宽其中一个数据进行计算即可
//        int be = 1;// be=1表示不缩放
//        // if (w > h && w > ww) {// 如果宽度大的话根据宽度固定大小缩放
//        be = (int) (w / ww);
//        // } else if (w < h && h > hh) {// 如果高度高的话根据宽度固定大小缩放
//        // be = (int) (newOpts.outHeight / hh);
//        // }
//        if (be <= 0)
//            be = 1;
//        newOpts.inSampleSize = be;// 设置缩放比例
//        try {
//            // 重新读入图片，注意此时已经把options.inJustDecodeBounds 设回false了
//            bitmap = BitmapFactory.decodeFile(src, newOpts);
//            try {
//                if (degree > 0) {
//                    bitmap = rotaingImageView(degree, bitmap);
//                }
//                OutputStream output = new FileOutputStream(IMAGE_FILE_SAVE_PATH
//                        + targetSrc);
//                bitmap.compress(Bitmap.CompressFormat.JPEG, 80, output);
//                // }
//                output.flush();
//                output.close();
//                newOpts = new BitmapFactory.Options();
//                if (w > 500) {
//                    newOpts.inSampleSize = 4;
//                } else {
//                    newOpts.inSampleSize = 1;
//                }
//                // 开始读入图片，此时把options.inJustDecodeBounds 设回true了
//                bitmap = BitmapFactory.decodeFile(IMAGE_FILE_SAVE_PATH
//                        + targetSrc, newOpts);// 此时返回bm为空
//            } catch (IOException e) {
//                // TODO Auto-generated catch block
//                e.printStackTrace();
//            }
//        } catch (Exception e) {
//        } catch (OutOfMemoryError e) {
//            System.gc();
//        }
//
//        return bitmap;
//        // return compressImage(bitmap);//压缩好比例大小后再进行质量压缩
//    }

    public static boolean isPic(String path) {
        String tmpName = path.substring(path.lastIndexOf(".") + 1,
                path.length());
        for (int i = 0; i < picType.length; i++) {
            // 判断单个类型文件的场合
            if (picType[i].equals(tmpName.toLowerCase())) {
                return true;
            }
        }
        return false;
    }


    /**
     * 压缩图片，处理某些手机拍照角度旋转的问题
     */
    public static String compressImage(Context context,String filePath)
            throws FileNotFoundException {

        Bitmap bm = getSmallBitmap(context, filePath);

        File srcFile = new File(filePath);
        File outputFile = new File(
                StorageUtils.getCacheDirectory(context),
                srcFile.getName());

        int degree = readPictureDegree(filePath);

        if (degree != 0) {// 旋转照片角度
            bm = rotaingImageView(degree, bm);
        }

        FileOutputStream out = new FileOutputStream(outputFile);

        bm.compress(Bitmap.CompressFormat.JPEG, 70, out);

        return outputFile.getPath();
    }

    // 根据路径获得图片并压缩，返回bitmap用于显示
    public static Bitmap getSmallBitmap(Context context,String filePath) {
        final BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(filePath, options);

        // Calculate inSampleSize
       if(NetWorkUtil.getAPNType(context) == NetWorkUtil.NetType.wifi){
           options.inSampleSize = calculateInSampleSize(options, 1920, 1920);
       }else{
           options.inSampleSize = calculateInSampleSize(options, 1280, 1280);
       }
//        options.inSampleSize = calculateInSampleSize(options, 800, 800);

        // Decode bitmap with inSampleSize set
        options.inJustDecodeBounds = false;

        return BitmapFactory.decodeFile(filePath, options);
    }

    // 根据路径获得图片并压缩，返回bitmap用于显示
    public static Bitmap getSmallBitmap(String filePath,int width,int height) {
        try {
            final BitmapFactory.Options options = new BitmapFactory.Options();
            options.inJustDecodeBounds = true;
            BitmapFactory.decodeFile(filePath, options);

            // Calculate inSampleSize
            options.inSampleSize = calculateInSampleSize(options, width, height);

            // Decode bitmap with inSampleSize set
            options.inJustDecodeBounds = false;

            return BitmapFactory.decodeFile(filePath, options);
        } catch (Throwable e) {
            return null;
        }
    }

    // 计算图片的缩放值
    public static int calculateInSampleSize(BitmapFactory.Options options,
                                            int reqWidth, int reqHeight) {
        final int height = options.outHeight;
        final int width = options.outWidth;
        int inSampleSize = 1;

        if (height > reqHeight || width > reqWidth) {
            final int heightRatio = new BigDecimal((float) height / (float) reqHeight).setScale(0, BigDecimal.ROUND_HALF_UP)
                    .intValue();
            final int widthRatio = new BigDecimal((float) width / (float) reqWidth).setScale(0, BigDecimal.ROUND_HALF_UP)
                    .intValue();
            /*final int heightRatio = new BigDecimal((float) height / (float) reqHeight).setScale(0, BigDecimal.ROUND_UP)
                    .intValue();
            final int widthRatio = new BigDecimal((float) width / (float) reqWidth).setScale(0, BigDecimal.ROUND_UP)
                    .intValue();*/
            inSampleSize = heightRatio > widthRatio ? heightRatio : widthRatio;
            if(inSampleSize<=1){
                inSampleSize=1;
            }
        }
        return inSampleSize;
    }

    /**
     * 读取图片属性：旋转的角度
     *
     * @param path
     *            图片绝对路径
     * @return degree 旋转的角度
     */
    public static int readPictureDegree(String path) {
        int degree = 0;
        try {
            ExifInterface exifInterface = new ExifInterface(path);
            int orientation = exifInterface.getAttributeInt(
                    ExifInterface.TAG_ORIENTATION,
                    ExifInterface.ORIENTATION_NORMAL);
            switch (orientation) {
                case ExifInterface.ORIENTATION_ROTATE_90:
                    degree = 90;
                    break;
                case ExifInterface.ORIENTATION_ROTATE_180:
                    degree = 180;
                    break;
                case ExifInterface.ORIENTATION_ROTATE_270:
                    degree = 270;
                    break;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        return degree;
    }

    /**
     * 旋转图片
     *
     * @param angle
     * @param bitmap
     * @return Bitmap
     */
    public static Bitmap rotaingImageView(int angle, Bitmap bitmap) {
        if(angle==0)
            return  bitmap;
        // 旋转图片 动作
        Matrix matrix = new Matrix();
        matrix.postRotate(angle);
        // 创建新的图片
        return Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(),
                bitmap.getHeight(), matrix, true);
    }




    /**
     * 将一张图片存储到LruCache中。
     *
     * @param key
     *            LruCache的键，这里传入图片的URL地址。
     * @param bitmap
     *            LruCache的键，这里传入从网络上下载的Bitmap对象。
     */
    public static void addBitmapToMemoryCache(String key, Bitmap bitmap) {
        if (mMemoryCache == null) {
            initCacheSize();
        }
        if (!TextUtils.isEmpty(key)&&getCacheBitmap(key) == null && bitmap != null) {
            mMemoryCache.put(key, bitmap);
        }
    }

    public static Bitmap getCacheBitmap(String path) {
        if (mMemoryCache == null) {
            initCacheSize();
        }
        if(TextUtils.isEmpty(path))
            return null;
        return mMemoryCache.get(path);
    }

    public static void initCacheSize() {
        // 获取应用程序最大可用内存
        int maxMemory = (int) Runtime.getRuntime().maxMemory();
        int cacheSize = maxMemory / 5;
        // 设置图片缓存大小为程序最大可用内存的1/8
        mMemoryCache = new LruCache<String, Bitmap>(cacheSize) {
            @Override
            protected int sizeOf(String key, Bitmap bitmap) {
                return bitmap.getRowBytes() * bitmap.getHeight();
            }
        };
    }

    public static void clearCache() {
        if(mMemoryCache!=null)
            mMemoryCache.evictAll();
    }

    /**
     * 根据手机的分辨率从 dp 的单位 转成为 px(像素)
     */
    public static int dip2px(Context context, float dpValue) {
        final float scale = context.getResources().getDisplayMetrics().density;
        return (int) (dpValue * scale + 0.5f);
    }

    /**
     * 根据手机的分辨率从 px(像素) 的单位 转成为 dp
     */
    public static int px2dip(Context context, float pxValue) {
        final float scale = context.getResources().getDisplayMetrics().density;
        return (int) (pxValue / scale + 0.5f);
    }

}
千寻之森
关注
专栏目录
非常实用的Android图片工具类
01-05
本文实例为大家分享了Android图片工具类的具体代码，供大家参考，具体内容如下 import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileNotFoundException; import java.io....
裁剪图片中遇到问题，怎么解决？
weixin_34279184的博客
04-13 108
2019独角兽企业重金招聘Python工程师标准>>> ...
Android 图片处理工具
zuo_er_lyf的博客
04-25 396
封装一些图片处理工具，记录下：public class ImageUtil { public final static String cachePath = Environment.getExternalStorageDirectory().getPath() + "/glory_bianyitong/cache/"; /** * 图片保存到SdCard中 *...
android studio 适配android7.0 android 6.0拍照调用系统裁剪工具实现头像上传功能
liufatao的博客
05-17 1750
之前在做新项目是把以前的上传头像功能复制过来，运行发现闪退了，当时就是各种排除，然后用模拟器运行是没问题的，但是用真机运行就报错，然后各种筛查，还是无果，然后我就想是不是手机问题手机不兼容，于是我用相同型号的手机测试发现同样可以使用就我的手机不能使用，当时就陷入沉思，唉是不是系统问题，我查看了手机系统版本，我的是最新的系统android7.0 另外的是android5.0 .于是我上网查了下发现果
完美解决 trying to use a recycled bitmap android.graphics.Bitmap@41d的异常
热门推荐
VIPqiangqiang的专栏
03-06 2万+
在最近一个项目中，因为要使用AnimationDrawable进行动画播放，图片质量都比较大，而且播放的频率会很多，开发的行车记录仪的内存又有限，刚开始并没有将Bitmap recycle掉,所以出现了OOM的异常。为了解决内存溢出问题，在退出当前页面的时候，将Bitmap recycle掉。但是在此又遇到了另外一个问题，退出当前界面再进入这个页面的时候会报出   trying to use
Android实用工具之二—APK工具
千寻
01-11 442
package net.hyww.utils; import android.content.Context; import android.content.Intent; import android.content.pm.ApplicationInfo; import android.content.pm.PackageManager; import android.net.Uri; /*
Android图片处理工具类BitmapUtils
08-28
【Android图片处理工具类BitmapUtils】是Android应用开发中用于高效管理和操作Bitmap对象的一个实用工具类。Bitmap在Android系统中是表示图像数据的核心类，它提供了丰富的图像处理功能，但处理不当可能导致内存溢出...
Android开发之超强图片工具类BitmapUtil完整实例
08-28
本篇文章主要介绍了Android开发之超强图片工具类BitmapUtil，结合完整实例形式分析了Android图片的常用操作技巧，包括图片的加载、转换、缩放、计算等相关操作技巧。 一、BitmapUtil类的作用 BitmapUtil类是一个...
Android串口工具
06-09
在Android设备上，UART是最常用的一种串口通信方式。 2. UART工作原理：UART是一种简单且低功耗的串行通信协议，由发送器、接收器和控制线组成。它包含两条数据线，一条是TX（Transmit），负责发送数据；另一条是RX...
Android拍照及选择图片及裁剪及兼容6.0权限实现
If rest, rust!
10-19 3161
来到新公司接手项目之后，测试总是给我测出拍照，选择图片，裁剪的各种bug，比如换个手机就不行了，或者换个6.0的系统就不行了等等这样的问题，因为这个代码是之前的一个同事写的，代码很乱，改来改去，硬是没有改好，于是，就决定自己动手写一个，现在分享给大家。 整个demo只有一个界面，由一个CheckBox，一个ImageView，一个TextViw组成，CheckBox用来标记是否要进行裁剪，来看一下布
split()方法注意
千寻
12-14 2114
split(),如果是要分割"."、"|"、"^"等字符做分隔符时，要写成s3.split("\\^")的格式，
EditText限制输入数字，精确到小数点后1位设置
千寻
01-02 1972
在EditText的布局文件里面设置： android:inputType="numberDecimal" 在代码中： /** 输入框小数的位数*/ private static final int DECIMAL_DIGITS = 1; InputFilter lengthfilter = new InputFilter() { public CharSe
三级联动（省市区）
千寻
12-04 1668
CityPickerDialog.getInstance(mContext, cstr, new CityPickerDialog.CallBack() { @Override public void call(String proId, String ctyId,String cyId, String city,String cc) { provinceId=pr
Android中string资源文件使用技巧
千寻
12-25 1443
1. html的使用：Html.fromHtml(getString(R.string.search_friend_no_content, "“ " + et_search.getText().toString().trim() + " ”"))    2.&nbsp|&quot|&amp|&lt|&gt等html字符转义 3.string标签里面可以使用： <font color=
Android sdk 30 无法查看源码解决方案
千寻
08-12 1270
网上大多数是修改项目配置，我这里介绍一种伪装法，29到30变动不大，可以把29源码伪装成30源码。 复制D:\program\androidsdk\sources 里面 29的文件夹，改名为30，然后修改D:\program\androidsdk\sources\android-30 里面 package.xml、source.properties中 29的全改成30。 然后重启 AndroidStudio ...
kotlin位运算的坑
千寻
08-04 1175
java中位运算 digest 是 byte数组 digest[i] & 0xff 不能替换成 (digest[i] and 0xff.toByte()).toInt() 因为kotlin位运算只针对int类型和long类型 需要改成 digest[i].toInt() and 0xff
外层竖向ScrollView，里层横向ScrollView滑动冲突
千寻
01-26 1171
public class CustomScrollView extends ScrollView { private GestureDetector mGestureDetector; View.OnTouchListener mGestureListener; @SuppressWarnings("deprecation") public CustomScrollView(Context
Viewpager和轮播图的冲突
千寻
03-21 1141
switch (ev.getAction()) {     case MotionEvent.ACTION_DOWN:       // 让当前viewpager的父控件不去拦截touch事件       getParent().requestDisallowInterceptTouchEvent(true);       downX = (int)
Android实用工具之一—时间戳工具
千寻
01-11 1021
import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; /** * Created by wuqiqi on 15-11-14. */ public class TimestampUtils { priva
Android BitmapUtils：图片处理实用工具详解
"Android图片处理工具类BitmapUtils是Android开发中常用的一个辅助工具，主要用于高效地管理和处理应用程序中的图片资源，以优化内存占用和提高用户体验。这个工具类提供了一系列针对图片的处理方法，包括但不限于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值