package net.oschina.app.util;
import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import android.app.Activity;
import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.Bitmap.CompressFormat;
import android.graphics.Bitmap.Config;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.LinearGradient;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.PixelFormat;
import android.graphics.PorterDuff.Mode;
import android.graphics.PorterDuffXfermode;
import android.graphics.Rect;
import android.graphics.RectF;
import android.graphics.Shader.TileMode;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.net.Uri;
import android.os.Environment;
import android.provider.MediaStore;
import android.provider.MediaStore.MediaColumns;
import android.util.DisplayMetrics;
/**
* 图片操作工具包
*
* @author liux (http://my.oschina.net/liux)
* @version 1.0
* @created 2012-3-21
*/
public class ImageUtils {
public final static String SDCARD_MNT = "/mnt/sdcard";
public final static String SDCARD = "/sdcard";
/** 请求相册 */
public static final int REQUEST_CODE_GETIMAGE_BYSDCARD = 0;
/** 请求相机 */
public static final int REQUEST_CODE_GETIMAGE_BYCAMERA = 1;
/** 请求裁剪 */
public static final int REQUEST_CODE_GETIMAGE_BYCROP = 2;
/** 从图片浏览界面发送动弹 */
public static final int REQUEST_CODE_GETIMAGE_IMAGEPAVER = 3;
/**
* 写图片文件 在Android系统中，文件保存在 /data/data/PACKAGE_NAME/files 目录下
*
* @throws IOException
*/
public static void saveImage(Context context, String fileName, Bitmap bitmap)
throws IOException {
saveImage(context, fileName, bitmap, 100);
}
public static void saveImage(Context context, String fileName,
Bitmap bitmap, int quality) throws IOException {
if (bitmap == null || fileName == null || context == null)
return;
FileOutputStream fos = context.openFileOutput(fileName,
Context.MODE_PRIVATE);
ByteArrayOutputStream stream = new ByteArrayOutputStream();
bitmap.compress(CompressFormat.JPEG, quality, stream);
byte[] bytes = stream.toByteArray();
fos.write(bytes);
fos.close();
}
/**
* 写图片文件到SD卡
*
* @throws IOException
*/
public static void saveImageToSD(Context ctx, String filePath,
Bitmap bitmap, int quality) throws IOException {
if (bitmap != null) {
File file = new File(filePath.substring(0,
filePath.lastIndexOf(File.separator)));
if (!file.exists()) {
file.mkdirs();
}
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream(filePath));
bitmap.compress(CompressFormat.JPEG, quality, bos);
bos.flush();
bos.close();
if (ctx != null) {
scanPhoto(ctx, filePath);
}
}
}
public static void saveBackgroundImage(Context ctx, String filePath,
Bitmap bitmap, int quality) throws IOException {
if (bitmap != null) {
File file = new File(filePath.substring(0,
filePath.lastIndexOf(File.separator)));
if (!file.exists()) {
file.mkdirs();
}
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream(filePath));
bitmap.compress(CompressFormat.PNG, quality, bos);
bos.flush();
bos.close();
if (ctx != null) {
scanPhoto(ctx, filePath);
}
}
}
/**
* 让Gallery上能马上看到该图片
*/
private static void scanPhoto(Context ctx, String imgFileName) {
Intent mediaScanIntent = new Intent(
Intent.ACTION_MEDIA_SCANNER_SCAN_FILE);
File file = new File(imgFileName);
Uri contentUri = Uri.fromFile(file);
mediaScanIntent.setData(contentUri);
ctx.sendBroadcast(mediaScanIntent);
}
/**
* 获取bitmap
*
* @param context
* @param fileName
* @return
*/
public static Bitmap getBitmap(Context context, String fileName) {
FileInputStream fis = null;
Bitmap bitmap = null;
try {
fis = context.openFileInput(fileName);
bitmap = BitmapFactory.decodeStream(fis);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (OutOfMemoryError e) {
e.printStackTrace();
} finally {
try {
fis.close();
} catch (Exception e) {
}
}
return bitmap;
}
/**
* 获取bitmap
*
* @param filePath
* @return
*/
public static Bitmap getBitmapByPath(String filePath) {
return getBitmapByPath(filePath, null);
}
public static Bitmap getBitmapByPath(String filePath,
BitmapFactory.Options opts) {
FileInputStream fis = null;
Bitmap bitmap = null;
try {
File file = new File(filePath);
fis = new FileInputStream(file);
bitmap = BitmapFactory.decodeStream(fis, null, opts);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (OutOfMemoryError e) {
e.printStackTrace();
} finally {
try {
fis.close();
} catch (Exception e) {
}
}
return bitmap;
}
/**
* 获取bitmap
*
* @param file
* @return
*/
public static Bitmap getBitmapByFile(File file) {
FileInputStream fis = null;
Bitmap bitmap = null;
try {
fis = new FileInputStream(file);
bitmap = BitmapFactory.decodeStream(fis);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (OutOfMemoryError e) {
e.printStackTrace();
} finally {
try {
fis.close();
} catch (Exception e) {
}
}
return bitmap;
}
/**
* 使用当前时间戳拼接一个唯一的文件名
*
* @param format
* @return
*/
public static String getTempFileName() {
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd_HH-mm-ss_SS");
String fileName = format.format(new Timestamp(System
.currentTimeMillis()));
return fileName;
}
/**
* 获取照相机使用的目录
*
* @return
*/
public static String getCamerPath() {
return Environment.getExternalStorageDirectory() + File.separator
+ "FounderNews" + File.separator;
}
/**
* 判断当前Url是否标准的content://样式，如果不是，则返回绝对路径
*
* @param uri
* @return
*/
public static String getAbsolutePathFromNoStandardUri(Uri mUri) {
String filePath = null;
String mUriString = mUri.toString();
mUriString = Uri.decode(mUriString);
String pre1 = "file://" + SDCARD + File.separator;
String pre2 = "file://" + SDCARD_MNT + File.separator;
if (mUriString.startsWith(pre1)) {
filePath = Environment.getExternalStorageDirectory().getPath()
+ File.separator + mUriString.substring(pre1.length());
} else if (mUriString.startsWith(pre2)) {
filePath = Environment.getExternalStorageDirectory().getPath()
+ File.separator + mUriString.substring(pre2.length());
}
return filePath;
}
/**
* 通过uri获取文件的绝对路径
*
* @param uri
* @return
*/
@SuppressWarnings("deprecation")
public static String getAbsoluteImagePath(Activity context, Uri uri) {
String imagePath = "";
String[] proj = { MediaStore.Images.Media.DATA };
Cursor cursor = context.managedQuery(uri, proj, // Which columns to
// return
null, // WHERE clause; which rows to return (all rows)
null, // WHERE clause selection arguments (none)
null); // Order-by clause (ascending by name)
if (cursor != null) {
int column_index = cursor
.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
if (cursor.getCount() > 0 && cursor.moveToFirst()) {
imagePath = cursor.getString(column_index);
}
}
return imagePath;
}
/**
* 获取图片缩略图 只有Android2.1以上版本支持
*
* @param imgName
* @param kind
* MediaStore.Images.Thumbnails.MICRO_KIND
* @return
*/
@SuppressWarnings("deprecation")
public static Bitmap loadImgThumbnail(Activity context, String imgName,
int kind) {
Bitmap bitmap = null;
String[] proj = { MediaStore.Images.Media._ID,
MediaStore.Images.Media.DISPLAY_NAME };
Cursor cursor = context.managedQuery(
MediaStore.Images.Media.EXTERNAL_CONTENT_URI, proj,
MediaStore.Images.Media.DISPLAY_NAME + "='" + imgName + "'",
null, null);
if (cursor != null && cursor.getCount() > 0 && cursor.moveToFirst()) {
ContentResolver crThumb = context.getContentResolver();
BitmapFactory.Options options = new BitmapFactory.Options();
options.inSampleSize = 1;
bitmap = MethodsCompat.getThumbnail(crThumb, cursor.getInt(0),
kind, options);
}
return bitmap;
}
public static Bitmap loadImgThumbnail(String filePath, int w, int h) {
Bitmap bitmap = getBitmapByPath(filePath);
return zoomBitmap(bitmap, w, h);
}
/**
* 获取SD卡中最新图片路径
*
* @return
*/
public static String getLatestImage(Activity context) {
String latestImage = null;
String[] items = { MediaStore.Images.Media._ID,
MediaStore.Images.Media.DATA };
Cursor cursor = context.managedQuery(
MediaStore.Images.Media.EXTERNAL_CONTENT_URI, items, null,
null, MediaStore.Images.Media._ID + " desc");
if (cursor != null && cursor.getCount() > 0) {
cursor.moveToFirst();
for (cursor.moveToFirst(); !cursor.isAfterLast(); cursor
.moveToNext()) {
latestImage = cursor.getString(1);
break;
}
}
return latestImage;
}
/**
* 计算缩放图片的宽高
*
* @param img_size
* @param square_size
* @return
*/
public static int[] scaleImageSize(int[] img_size, int square_size) {
if (img_size[0] <= square_size && img_size[1] <= square_size)
return img_size;
double ratio = square_size
/ (double) Math.max(img_size[0], img_size[1]);
return new int[] { (int) (img_size[0] * ratio),
(int) (img_size[1] * ratio) };
}
/**
* 创建缩略图
*
* @param context
* @param largeImagePath
* 原始大图路径
* @param thumbfilePath
* 输出缩略图路径
* @param square_size
* 输出图片宽度
* @param quality
* 输出图片质量
* @throws IOException
*/
public static void createImageThumbnail(Context context,
String largeImagePath, String thumbfilePath, int square_size,
int quality) throws IOException {
BitmapFactory.Options opts = new BitmapFactory.Options();
opts.inSampleSize = 1;
// 原始图片bitmap
Bitmap cur_bitmap = getBitmapByPath(largeImagePath, opts);
if (cur_bitmap == null)
return;
// 原始图片的高宽
int[] cur_img_size = new int[] { cur_bitmap.getWidth(),
cur_bitmap.getHeight() };
// 计算原始图片缩放后的宽高
int[] new_img_size = scaleImageSize(cur_img_size, square_size);
// 生成缩放后的bitmap
Bitmap thb_bitmap = zoomBitmap(cur_bitmap, new_img_size[0],
new_img_size[1]);
// 生成缩放后的图片文件
saveImageToSD(null, thumbfilePath, thb_bitmap, quality);
}
/**
* 放大缩小图片
*
* @param bitmap
* @param w
* @param h
* @return
*/
public static Bitmap zoomBitmap(Bitmap bitmap, int w, int h) {
Bitmap newbmp = null;
if (bitmap != null) {
int width = bitmap.getWidth();
int height = bitmap.getHeight();
Matrix matrix = new Matrix();
float scaleWidht = ((float) w / width);
float scaleHeight = ((float) h / height);
matrix.postScale(scaleWidht, scaleHeight);
newbmp = Bitmap.createBitmap(bitmap, 0, 0, width, height, matrix,
true);
}
return newbmp;
}
public static Bitmap scaleBitmap(Bitmap bitmap) {
// 获取这个图片的宽和高
int width = bitmap.getWidth();
int height = bitmap.getHeight();
// 定义预转换成的图片的宽度和高度
int newWidth = 200;
int newHeight = 200;
// 计算缩放率，新尺寸除原始尺寸
float scaleWidth = ((float) newWidth) / width;
float scaleHeight = ((float) newHeight) / height;
// 创建操作图片用的matrix对象
Matrix matrix = new Matrix();
// 缩放图片动作
matrix.postScale(scaleWidth, scaleHeight);
// 旋转图片 动作
// matrix.postRotate(45);
// 创建新的图片
Bitmap resizedBitmap = Bitmap.createBitmap(bitmap, 0, 0, width, height,
matrix, true);
return resizedBitmap;
}
/**
* (缩放)重绘图片
*
* @param context
* Activity
* @param bitmap
* @return
*/
public static Bitmap reDrawBitMap(Activity context, Bitmap bitmap) {
DisplayMetrics dm = new DisplayMetrics();
context.getWindowManager().getDefaultDisplay().getMetrics(dm);
int rHeight = dm.heightPixels;
int rWidth = dm.widthPixels;
// float rHeight=dm.heightPixels/dm.density+0.5f;
// float rWidth=dm.widthPixels/dm.density+0.5f;
// int height=bitmap.getScaledHeight(dm);
// int width = bitmap.getScaledWidth(dm);
int height = bitmap.getHeight();
int width = bitmap.getWidth();
float zoomScale;
/** 方式3 **/
if (width >= rWidth)
zoomScale = ((float) rWidth) / width;
else
zoomScale = 1.0f;
// 创建操作图片用的matrix对象
Matrix matrix = new Matrix();
// 缩放图片动作
matrix.postScale(zoomScale, zoomScale);
Bitmap resizedBitmap = Bitmap.createBitmap(bitmap, 0, 0,
bitmap.getWidth(), bitmap.getHeight(), matrix, true);
return resizedBitmap;
}
/**
* 将Drawable转化为Bitmap
*
* @param drawable
* @return
*/
public static Bitmap drawableToBitmap(Drawable drawable) {
int width = drawable.getIntrinsicWidth();
int height = drawable.getIntrinsicHeight();
Bitmap bitmap = Bitmap.createBitmap(width, height, drawable
.getOpacity() != PixelFormat.OPAQUE ? Bitmap.Config.ARGB_8888
: Bitmap.Config.RGB_565);
Canvas canvas = new Canvas(bitmap);
drawable.setBounds(0, 0, width, height);
drawable.draw(canvas);
return bitmap;
}
/**
* 获得圆角图片的方法
*
* @param bitmap
* @param roundPx
* 一般设成14
* @return
*/
public static Bitmap getRoundedCornerBitmap(Bitmap bitmap, float roundPx) {
Bitmap output = Bitmap.createBitmap(bitmap.getWidth(),
bitmap.getHeight(), Config.ARGB_8888);
Canvas canvas = new Canvas(output);
final int color = 0xff424242;
final Paint paint = new Paint();
final Rect rect = new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight());
final RectF rectF = new RectF(rect);
paint.setAntiAlias(true);
canvas.drawARGB(0, 0, 0, 0);
paint.setColor(color);
canvas.drawRoundRect(rectF, roundPx, roundPx, paint);
paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN));
canvas.drawBitmap(bitmap, rect, rect, paint);
return output;
}
/**
* 获得带倒影的图片方法
*
* @param bitmap
* @return
*/
public static Bitmap createReflectionImageWithOrigin(Bitmap bitmap) {
final int reflectionGap = 4;
int width = bitmap.getWidth();
int height = bitmap.getHeight();
Matrix matrix = new Matrix();
matrix.preScale(1, -1);
Bitmap reflectionImage = Bitmap.createBitmap(bitmap, 0, height / 2,
width, height / 2, matrix, false);
Bitmap bitmapWithReflection = Bitmap.createBitmap(width,
(height + height / 2), Config.ARGB_8888);
Canvas canvas = new Canvas(bitmapWithReflection);
canvas.drawBitmap(bitmap, 0, 0, null);
Paint deafalutPaint = new Paint();
canvas.drawRect(0, height, width, height + reflectionGap, deafalutPaint);
canvas.drawBitmap(reflectionImage, 0, height + reflectionGap, null);
Paint paint = new Paint();
LinearGradient shader = new LinearGradient(0, bitmap.getHeight(), 0,
bitmapWithReflection.getHeight() + reflectionGap, 0x70ffffff,
0x00ffffff, TileMode.CLAMP);
paint.setShader(shader);
// Set the Transfer mode to be porter duff and destination in
paint.setXfermode(new PorterDuffXfermode(Mode.DST_IN));
// Draw a rectangle using the paint with our linear gradient
canvas.drawRect(0, height, width, bitmapWithReflection.getHeight()
+ reflectionGap, paint);
return bitmapWithReflection;
}
/**
* 将bitmap转化为drawable
*
* @param bitmap
* @return
*/
public static Drawable bitmapToDrawable(Bitmap bitmap) {
Drawable drawable = new BitmapDrawable(bitmap);
return drawable;
}
/**
* 获取图片类型
*
* @param file
* @return
*/
public static String getImageType(File file) {
if (file == null || !file.exists()) {
return null;
}
InputStream in = null;
try {
in = new FileInputStream(file);
String type = getImageType(in);
return type;
} catch (IOException e) {
return null;
} finally {
try {
if (in != null) {
in.close();
}
} catch (IOException e) {
}
}
}
/**
* 获取图片的类型信息
*
* @param in
* @return
* @see #getImageType(byte[])
*/
public static String getImageType(InputStream in) {
if (in == null) {
return null;
}
try {
byte[] bytes = new byte[8];
in.read(bytes);
return getImageType(bytes);
} catch (IOException e) {
return null;
}
}
/**
* 获取图片的类型信息
*
* @param bytes
* 2~8 byte at beginning of the image file
* @return image mimetype or null if the file is not image
*/
public static String getImageType(byte[] bytes) {
if (isJPEG(bytes)) {
return "image/jpeg";
}
if (isGIF(bytes)) {
return "image/gif";
}
if (isPNG(bytes)) {
return "image/png";
}
if (isBMP(bytes)) {
return "application/x-bmp";
}
return null;
}
private static boolean isJPEG(byte[] b) {
if (b.length < 2) {
return false;
}
return (b[0] == (byte) 0xFF) && (b[1] == (byte) 0xD8);
}
private static boolean isGIF(byte[] b) {
if (b.length < 6) {
return false;
}
return b[0] == 'G' && b[1] == 'I' && b[2] == 'F' && b[3] == '8'
&& (b[4] == '7' || b[4] == '9') && b[5] == 'a';
}
private static boolean isPNG(byte[] b) {
if (b.length < 8) {
return false;
}
return (b[0] == (byte) 137 && b[1] == (byte) 80 && b[2] == (byte) 78
&& b[3] == (byte) 71 && b[4] == (byte) 13 && b[5] == (byte) 10
&& b[6] == (byte) 26 && b[7] == (byte) 10);
}
private static boolean isBMP(byte[] b) {
if (b.length < 2) {
return false;
}
return (b[0] == 0x42) && (b[1] == 0x4d);
}
/**
* 获取图片路径 2014年8月12日
*
* @param uri
* @param cursor
* @return E-mail:mr.huangwenwei@gmail.com
*/
public static String getImagePath(Uri uri, Activity context) {
String[] projection = { MediaColumns.DATA };
Cursor cursor = context.getContentResolver().query(uri, projection,
null, null, null);
if (cursor != null) {
cursor.moveToFirst();
int columIndex = cursor.getColumnIndexOrThrow(MediaColumns.DATA);
String ImagePath = cursor.getString(columIndex);
cursor.close();
return ImagePath;
}
return uri.toString();
}
static Bitmap bitmap = null;
/**
* 2014年8月13日
*
* @param uri
* @param context
* E-mail:mr.huangwenwei@gmail.com
*/
public static Bitmap loadPicasaImageFromGalley(final Uri uri,
final Activity context) {
String[] projection = { MediaColumns.DATA, MediaColumns.DISPLAY_NAME };
Cursor cursor = context.getContentResolver().query(uri, projection,
null, null, null);
if (cursor != null) {
cursor.moveToFirst();
int columIndex = cursor.getColumnIndex(MediaColumns.DISPLAY_NAME);
if (columIndex != -1) {
new Thread(new Runnable() {
@Override
public void run() {
try {
bitmap = android.provider.MediaStore.Images.Media
.getBitmap(context.getContentResolver(),
uri);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}).start();
}
cursor.close();
return bitmap;
} else
return null;
}
}
相关推荐
本项目是基于C#语言实现的图像处理工具包，它提供了一系列高效且用户友好的功能，如图像灰度直方图计算、图像平滑、图像增强以及图像纠正。下面将详细介绍这些知识点。 1. **C#实现的图像处理**： C#是一种广泛...
总之，"安卓开发框架工具类相关-可以拍照和选择图片的工具.rar" 是一个实用的开发资源，它涵盖了安卓应用中常见的图片操作功能，可以帮助开发者快速实现相关功能，同时也提供了学习和研究的机会。在使用时，应结合...
本主题将详细探讨一个名为“剪切图片的工具类”的功能，它主要用于对图片进行剪切和缩放操作。这类工具类在编程中通常会提供一系列方法，帮助开发者实现对图像的精确操作。 首先，我们需要理解“剪切”图片的概念。...
在实际开发中，这些功能可能通过Java的`java.awt.image`和`javax.imageio`包来实现，利用BufferedImage类进行图像处理，以及ImageIO类进行读写操作。`ImageUtils`类通常会封装这些复杂的API，提供更友好的接口供其他...
"Bitmap图片处理工具类" 提供了多种对位图（Bitmap）进行操作的功能，如颜色转换、图像分割、缩放、旋转、调整透明度、生成圆角图片以及文字与倒影效果的绘制。接下来，我们将深入探讨这些知识点。 首先，`...
因为有`ImageUtils.java`这个文件）中的图像处理库，如Java的Java Advanced Imaging (JAI) 或者 Apache Commons Imaging 库，通过它们提供的API来实现图片的读取、裁剪、调整大小以及组合等操作。 其次，**图片压缩...
在IT行业中，图片处理...这个工具类对于需要处理大量图片的项目非常有用，它简化了常见图片操作的实现，提高了开发效率。通过阅读和理解`ImageUtils.java`的源代码，我们可以学习到Java图形处理的基本技巧和最佳实践。
3. 图片加载：xUtils3的ImageUtils模块提供了图片加载和缓存的功能。开发者可以通过简单的API调用来实现图片的异步加载，同时支持多种加载策略，如内存缓存、磁盘缓存、网络加载等。此外，xUtils3还提供了图片的裁剪...
描述中提到"通过opencv和RGB判断输入图片"，这意味着`ImageUtils.py`可能包含了读取图片，转换到RGB色彩空间，然后应用上述颜色阈值和形态学操作的代码。为了进一步提高识别准确率，可能还会涉及其他特征，如边缘...
通常，一个工具类库会包含各种不同分类的工具类，如字符串处理、日期时间、网络请求、图片处理、文件操作等。在“MyUtils-master”中，我们可以期待找到这些功能的实现。 1. 字符串处理：在Android开发中，字符串...
FtpUtils - 操作FTP的工具类（基于sun自家的包，jdk7以后不建议使用） FtpUtilsApache - 基于apache操作FTP的工具类 HttpUtils - 发送HTTP请求 IpUtils - 获取IP SFtpUtils - 操作SFTP的工具类 prop ...
在实际项目开发中，图片处理是一项常见的需求，包括但不限于图片的压缩、尺寸调整以及添加水印等操作。传统的Java库虽然能够实现这些功能，但往往在图片质量方面不尽如人意，尤其是当图片尺寸被大幅度压缩时，画质...
4. **文件操作工具类**：在处理本地存储时，`FileUtils`可以帮助读写文件、创建目录、删除文件等。例如，`writeToFile()`方法用于将数据写入文件，`readFromFile()`用于读取文件内容。 5. **UI组件交互工具类**：在...
本文将深入探讨“Android常用工具类”，特别是基于`xUtils`库，这是一个广受欢迎的Android开发工具包。`xUtils`是由国内开发者吴成铖创建的，它包含了网络请求、数据库操作、图片加载等多个模块，极大地提高了开发...
xUtils是由国内知名开发者吴成锋（wubin）开发的一个轻量级、全方位的Android开发工具包，它极大地简化了Android开发过程中的一些常见任务，如网络请求、图片加载、数据库操作等。接下来，我们将详细探讨xUtils ...
- `ImageUtils`：支持图片的压缩、裁剪、旋转、加载等操作，可能基于 Glide 或 Picasso 图片加载库。 6. **设备信息工具类**： - `DeviceInfoUtils`：获取设备信息，如设备型号、屏幕尺寸、系统版本等。 7. **...
这个过程涉及到图像处理和编程技术，尤其是Java语言的运用，因为提供的文件`ImageUtils.java`暗示这是一个用Java编写的图像处理工具类。 首先，我们需要理解水印的概念。水印可以是图形或者文字，通常以半透明的...
4. **文件及IO操作工具类**： - `FileUtils`：包含了文件的创建、删除、复制、移动等操作，以及读写文件的方法。 - `IOUtils`：用于处理输入输出流，如读取流到字符串，写字符串到流，关闭流等。 5. **图片处理...
6. **文件操作工具类**：`FileUtils`可以帮助开发者方便地读写文件、创建目录、复制移动文件等，简化IO操作。 7. **权限管理工具类**：随着Android权限模型的变化，`PermissionUtils`可以统一处理运行时权限的申请...
7. **文件操作工具类** `FileUtils`可能包含读写文件、创建文件夹、删除文件等操作，如`writeToFile()`写入数据到文件，`readFromFile()`读取文件内容。 8. **颜色与尺寸转换工具类** `ColorUtils`和`...