Android实现图片裁剪处理的操作步骤

千万别相信哥

前言

本文将介绍如何构建一个支持图片选择、裁剪（包括手动缩放和旋转）、以及保存到自定义路径的Android应用demo。

步骤 1: 设置权限

首先，在

1. AndroidManifest.xml

复制代码

中添加必要的权限：

1. <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
   
2. <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />

复制代码

对于 Android 6.0 (API level 23) 及以上版本，需要在运行时请求权限。

步骤 2: 创建布局文件

创建一个简单的布局文件

1. activity_main.xml

复制代码

，包含一个用于显示图片的

1. CustomCropImageView

复制代码

，以及几个按钮用于控制裁剪操作。

1. <?xml version="1.0" encoding="utf-8"?>
   
2. <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
   
3.     android:layout_width="match_parent"
   
4.     android:layout_height="match_parent">
   
5. 
   
6.     <com.example.CustomCropImageView
   
7.         android:id="@+id/customCropImageView"
   
8.         android:layout_width="match_parent"
   
9.         android:layout_height="wrap_content" />
   
10. 
    
11.     <Button
    
12.         android:id="@+id/buttonPickImage"
    
13.         android:layout_width="wrap_content"
    
14.         android:layout_height="wrap_content"
    
15.         android:text="Pick Image"
    
16.         android:layout_below="@id/customCropImageView" />
    
17. 
    
18.     <Button
    
19.         android:id="@+id/buttonCrop"
    
20.         android:layout_width="wrap_content"
    
21.         android:layout_height="wrap_content"
    
22.         android:text="Crop"
    
23.         android:layout_toEndOf="@id/buttonPickImage"
    
24.         android:layout_below="@id/customCropImageView" />
    
25. 
    
26.     <Button
    
27.         android:id="@+id/buttonCancel"
    
28.         android:layout_width="wrap_content"
    
29.         android:layout_height="wrap_content"
    
30.         android:text="Cancel"
    
31.         android:layout_toEndOf="@id/buttonCrop"
    
32.         android:layout_below="@id/customCropImageView" />
    
33. 
    
34.     <Button
    
35.         android:id="@+id/buttonSave"
    
36.         android:layout_width="wrap_content"
    
37.         android:layout_height="wrap_content"
    
38.         android:text="Save"
    
39.         android:layout_toEndOf="@id/buttonCancel"
    
40.         android:layout_below="@id/customCropImageView" />
    
41. </RelativeLayout>

复制代码

步骤 3: 实现自定义View CustomCropImageView

接下来，我们将详细实现

1. CustomCropImageView

复制代码

，这个自定义视图负责所有与裁剪相关的交互逻辑。

CustomCropImageView.java

1. ```java
   
2. import android.content.Context;
   
3. import android.graphics.Bitmap;
   
4. import android.graphics.Canvas;
   
5. import android.graphics.Color;
   
6. import android.graphics.Matrix;
   
7. import android.graphics.Paint;
   
8. import android.graphics.Path;
   
9. import android.graphics.PorterDuff;
   
10. import android.graphics.PorterDuffXfermode;
    
11. import android.graphics.RectF;
    
12. import android.util.AttributeSet;
    
13. import android.view.GestureDetector;
    
14. import android.view.MotionEvent;
    
15. import android.view.ScaleGestureDetector;
    
16. import android.widget.FrameLayout;
    
17. 
    
18. public class CustomCropImageView extends FrameLayout {
    
19. 
    
20.     // 成员变量定义
    
21.     private Bitmap mBitmap; // 要裁剪的图片
    
22.     private Matrix mMatrix = new Matrix(); // 用于变换（缩放、旋转）图像的矩阵
    
23.     private RectF mRect = new RectF(); // 定义裁剪框的位置和大小
    
24.     private float[] mLastTouchPos = new float[2]; // 上次触摸位置，用于计算移动距离
    
25.     private float[] mCurrentPos = new float[2]; // 当前触摸位置，用于更新图像位置
    
26.     private float mRotation = 0f; // 图像的旋转角度
    
27.     private boolean mIsDragging = false; // 标记是否正在拖动图像
    
28.     private ScaleGestureDetector mScaleDetector; // 检测多点触控缩放手势
    
29.     private GestureDetector mGestureDetector; // 检测单点触控手势（如点击）
    
30. 
    
31.     // 构造函数，初始化自定义视图
    
32.     public CustomCropImageView(Context context, AttributeSet attrs) {
    
33.         super(context, attrs);
    
34.         // 初始化手势检测器
    
35.         mScaleDetector = new ScaleGestureDetector(context, new ScaleListener());
    
36.         mGestureDetector = new GestureDetector(context, new GestureListener());
    
37.     }
    
38. 
    
39.     @Override
    
40.     protected void onDraw(Canvas canvas) {
    
41.         super.onDraw(canvas);
    
42. 
    
43.         if (mBitmap != null) {
    
44.             // 绘制背景蒙层，使非裁剪区域变暗
    
45.             drawOverlay(canvas);
    
46. 
    
47.             // 保存当前Canvas状态，以便稍后恢复
    
48.             canvas.save();
    
49.             // 将Canvas原点移动到裁剪框中心，进行旋转操作
    
50.             canvas.translate(mRect.centerX(), mRect.centerY());
    
51.             canvas.rotate(mRotation);
    
52.             // 移回原点以绘制旋转后的图像
    
53.             canvas.translate(-mRect.centerX(), -mRect.centerY());
    
54.             // 使用变换矩阵绘制图像
    
55.             canvas.drawBitmap(mBitmap, mMatrix, null);
    
56.             // 恢复Canvas到之前的状态
    
57.             canvas.restore();
    
58. 
    
59.             // 绘制裁剪框，让用户知道哪里会被裁剪
    
60.             drawCropBox(canvas);
    
61.         }
    
62.     }
    
63. 
    
64.     private void drawOverlay(Canvas canvas) {
    
65.         Paint paint = new Paint();
    
66.         // 设置半透明黑色作为蒙层颜色
    
67.         paint.setColor(Color.argb(128, 0, 0, 0));
    
68.         // 填充整个视图为半透明黑色
    
69.         canvas.drawRect(0, 0, getWidth(), getHeight(), paint);
    
70. 
    
71.         // 创建一个路径，添加裁剪框形状
    
72.         Path path = new Path();
    
73.         path.addRect(mRect, Path.Direction.CW);
    
74.         // 使用canvas.clipPath剪切出裁剪框区域，使其透明
    
75.         // 注意：Region.Op.DIFFERENCE在API 26以上已被弃用，应考虑使用其他方式实现相同效果
    
76.         canvas.clipPath(path, Region.Op.DIFFERENCE);
    
77.         canvas.drawColor(Color.TRANSPARENT, PorterDuff.Mode.CLEAR);
    
78.     }
    
79. 
    
80.     private void drawCropBox(Canvas canvas) {
    
81.         Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG); // 抗锯齿
    
82.         paint.setStyle(Paint.Style.STROKE); // 只绘制边框，不填充内部
    
83.         paint.setStrokeWidth(5); // 边框宽度
    
84.         paint.setColor(Color.BLUE); // 裁剪框颜色设置为蓝色
    
85.         // 绘制裁剪框矩形
    
86.         canvas.drawRect(mRect, paint);
    
87.     }
    
88. 
    
89.     @Override
    
90.     public boolean onTouchEvent(MotionEvent event) {
    
91.         // 分别将事件传递给缩放和手势检测器
    
92.         mScaleDetector.onTouchEvent(event);
    
93.         mGestureDetector.onTouchEvent(event);
    
94. 
    
95.         switch (event.getAction()) {
    
96.             case MotionEvent.ACTION_DOWN:
    
97.                 // 记录按下时的坐标，开始拖动
    
98.                 mLastTouchPos[0] = event.getX();
    
99.                 mLastTouchPos[1] = event.getY();
    
100.                 mIsDragging = true;
     
101.                 break;
     
102.             case MotionEvent.ACTION_MOVE:
     
103.                 if (mIsDragging) {
     
104.                     // 更新当前位置，并根据位移调整矩阵和平移裁剪框
     
105.                     mCurrentPos[0] = event.getX();
     
106.                     mCurrentPos[1] = event.getY();
     
107.                     updateMatrix();
     
108.                     invalidate(); // 请求重新绘制界面
     
109.                 }
     
110.                 break;
     
111.             case MotionEvent.ACTION_UP:
     
112.                 // 结束拖动
     
113.                 mIsDragging = false;
     
114.                 break;
     
115.         }
     
116.         return true;
     
117.     }
     
118. 
     
119.     private void updateMatrix() {
     
120.         // 更新矩阵以反映图像的新位置
     
121.         mMatrix.setTranslate(mCurrentPos[0] - mLastTouchPos[0], mCurrentPos[1] - mLastTouchPos[1]);
     
122.         // 同步裁剪框的位置
     
123.         mRect.offset(mCurrentPos[0] - mLastTouchPos[0], mCurrentPos[1] - mLastTouchPos[1]);
     
124.     }
     
125. 
     
126.     private class ScaleListener extends ScaleGestureDetector.SimpleOnScaleGestureListener {
     
127.         @Override
     
128.         public boolean onScale(ScaleGestureDetector detector) {
     
129.             // 获取缩放因子并应用到矩阵上，保持缩放中心点不变
     
130.             float scaleFactor = detector.getScaleFactor();
     
131.             mMatrix.postScale(scaleFactor, scaleFactor, detector.getFocusX(), detector.getFocusY());
     
132.             invalidate(); // 请求重绘以反映变化
     
133.             return true;
     
134.         }
     
135.     }
     
136. 
     
137.     private class GestureListener extends GestureDetector.SimpleOnGestureListener {
     
138.         @Override
     
139.         public boolean onDoubleTap(MotionEvent e) {
     
140.             // 双击时重置所有变换
     
141.             resetTransformations();
     
142.             return true;
     
143.         }
     
144.     }
     
145. 
     
146.     private void resetTransformations() {
     
147.         // 重置矩阵和旋转角度，以及裁剪框位置
     
148.         mMatrix.reset();
     
149.         mRotation = 0f;
     
150.         mRect.set(/* default values */);
     
151.         invalidate(); // 请求重绘
     
152.     }
     
153. 
     
154.     // 设置要裁剪的图片
     
155.     public void setImageBitmap(Bitmap bitmap) {
     
156.         mBitmap = bitmap;
     
157.         // 根据新图片尺寸调整裁剪框大小
     
158.         updateCropBoxSize();
     
159.         requestLayout(); // 请求布局更新
     
160.         invalidate(); // 请求重绘
     
161.     }
     
162. 
     
163.     private void updateCropBoxSize() {
     
164.         // 根据所选图片的尺寸设置合适的裁剪框大小
     
165.         int width = mBitmap.getWidth();
     
166.         int height = mBitmap.getHeight();
     
167.         float aspectRatio = (float) width / height;
     
168. 
     
169.         // 设定裁剪框的初始尺寸为图片的中心区域，同时确保其宽高比与原始图片一致
     
170.         float rectWidth = Math.min(getWidth(), getHeight() * aspectRatio);
     
171.         float rectHeight = Math.min(getHeight(), getWidth() / aspectRatio);
     
172.         mRect.set((getWidth() - rectWidth) / 2, (getHeight() - rectHeight) / 2, (getWidth() + rectWidth) / 2, (getHeight() + rectHeight) / 2);
     
173.     }
     
174. 
     
175.     // 获取裁剪后的图片
     
176.     public Bitmap getCroppedBitmap() {
     
177.         // 创建一个新的位图来容纳裁剪结果
     
178.         Bitmap croppedBitmap = Bitmap.createBitmap(
     
179.             (int)mRect.width(),
     
180.             (int)mRect.height(),
     
181.             Bitmap.Config.ARGB_8888
     
182.         );
     
183.         Canvas canvas = new Canvas(croppedBitmap);
     
184.         // 平移画布以对齐裁剪框左上角
     
185.         canvas.translate(-mRect.left, -mRect.top);
     
186.         // 绘制变换后的原始图片到新的位图中
     
187.         canvas.drawBitmap(mBitmap, mMatrix, null);
     
188.         return croppedBitmap;
     
189.     }
     
190. }

复制代码

自定义的

1. CustomCropImageView

复制代码

，它允许用户通过触摸屏交互来裁剪图片。该视图支持基本的手势操作，包括拖动、缩放和双击重置。此外，还提供了设置图片和获取裁剪后图片的方法。

步骤 4: 更新Activity逻辑

现在我们将更新

1. MainActivity.java

复制代码

，以加载图片到自定义视图，并处理裁剪后的保存逻辑。

MainActivity.java

1. import android.Manifest;
   
2. import android.content.Intent;
   
3. import android.content.pm.PackageManager;
   
4. import android.graphics.Bitmap;
   
5. import android.net.Uri;
   
6. import android.os.Bundle;
   
7. import android.provider.MediaStore;
   
8. import androidx.annotation.NonNull;
   
9. import androidx.annotation.Nullable;
   
10. import androidx.appcompat.app.AppCompatActivity;
    
11. import androidx.core.app.ActivityCompat;
    
12. import androidx.core.content.ContextCompat;
    
13. 
    
14. import java.io.File;
    
15. import java.io.FileOutputStream;
    
16. import java.io.IOException;
    
17. 
    
18. public class MainActivity extends AppCompatActivity {
    
19. 
    
20.     private static final int PICK_IMAGE_REQUEST = 1;
    
21.     private static final int REQUEST_PERMISSIONS = 2;
    
22.     private CustomCropImageView customCropImageView;
    
23.     private Uri imageUri;
    
24. 
    
25.     @Override
    
26.     protected void onCreate(Bundle savedInstanceState) {
    
27.         super.onCreate(savedInstanceState);
    
28.         setContentView(R.layout.activity_main);
    
29. 
    
30.         customCropImageView = findViewById(R.id.customCropImageView);
    
31. 
    
32.         // 检查并请求存储权限
    
33.         if (ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)
    
34.                 != PackageManager.PERMISSION_GRANTED) {
    
35.             ActivityCompat.requestPermissions(this,
    
36.                     new String[]{Manifest.permission.READ_EXTERNAL_STORAGE, Manifest.permission.WRITE_EXTERNAL_STORAGE},
    
37.                     REQUEST_PERMISSIONS);
    
38.         }
    
39. 
    
40.         findViewById(R.id.buttonPickImage).setOnClickListener(v -> pickImage());
    
41.         findViewById(R.id.buttonCrop).setOnClickListener(v -> cropImage());
    
42.         findViewById(R.id.buttonCancel).setOnClickListener(v -> cancelCrop());
    
43.         findViewById(R.id.buttonSave).setOnClickListener(v -> saveImage());
    
44.     }
    
45. 
    
46.     private void pickImage() {
    
47.         Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
    
48.         intent.setType("image/*");
    
49.         startActivityForResult(intent, PICK_IMAGE_REQUEST);
    
50.     }
    
51. 
    
52.     private void cropImage() {
    
53.         // 如果使用第三方库如uCrop，可以在这里启动裁剪活动
    
54.         // 这里我们假设CustomCropImageView已经包含了所有裁剪功能
    
55.         // 因此不需要启动新的活动。
    
56.     }
    
57. 
    
58.     private void cancelCrop() {
    
59.         // 重置CustomCropImageView的状态
    
60.         customCropImageView.resetTransformations();
    
61.     }
    
62. 
    
63.     private void saveImage() {
    
64.         Bitmap bitmap = customCropImageView.getCroppedBitmap(); // 获取裁剪后的位图
    
65.         try {
    
66.             File path = new File(getExternalFilesDir(null), "custom_folder");
    
67.             if (!path.exists()) {
    
68.                 path.mkdirs();
    
69.             }
    
70.             File file = new File(path, "cropped_image.jpg");
    
71.             FileOutputStream out = new FileOutputStream(file);
    
72.             bitmap.compress(Bitmap.CompressFormat.JPEG, 90, out);
    
73.             out.flush();
    
74.             out.close();
    
75.             // 提示用户图片已保存
    
76.         } catch (IOException e) {
    
77.             e.printStackTrace();
    
78.             // 处理保存失败的情况
    
79.         }
    
80.     }
    
81. 
    
82.     @Override
    
83.     protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
    
84.         super.onActivityResult(requestCode, resultCode, data);
    
85.         if (requestCode == PICK_IMAGE_REQUEST && resultCode == RESULT_OK && data != null && data.getData() != null) {
    
86.             imageUri = data.getData();
    
87.             try {
    
88.                 // 将选择的图片加载到CustomCropImageView中
    
89.                 Bitmap bitmap = MediaStore.Images.Media.getBitmap(getContentResolver(), imageUri);
    
90.                 customCropImageView.setImageBitmap(bitmap);
    
91.             } catch (IOException e) {
    
92.                 e.printStackTrace();
    
93.             }
    
94.         }
    
95.     }
    
96. 
    
97.     @Override
    
98.     public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
    
99.         super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    
100.         if (requestCode == REQUEST_PERMISSIONS) {
     
101.             if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
     
102.                 // 权限授予成功，可以继续进行图片选择等操作
     
103.             } else {
     
104.                 // 用户拒绝了权限，需要提示用户或者禁用相关功能
     
105.             }
     
106.         }
     
107.     }
     
108. }

复制代码

总结

通过上述步骤，我们完成了一个具有裁剪功能的Android demo。该应用允许用户从相册或相机选择图片，在界面上进行裁剪、旋转和缩放，并最终将处理过的图片保存到指定位置。
以上就是Android实现图片裁剪处理的操作步骤的详细内容，更多关于Android图片裁剪处理的资料请关注晓枫资讯其它相关文章！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！