android 相机图库调用以及裁剪

最新推荐文章于 2023-02-22 08:03:53 发布
最新推荐文章于 2023-02-22 08:03:53 发布
阅读量684 收藏
点赞数
分类专栏： 积累
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/whuthm/article/details/47701235
版权

相机调用

private void selectPicFromCamera() {
        mOutputFile = getPicFile(getActivity());
        Log.e(TAG,
                "selectPicFromGallery : " + mOutputFile.getPath() + "  "
                        + mOutputFile.exists());
        Uri pcUri = Uri.fromFile(mOutputFile);
        Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
        intent.putExtra(MediaStore.EXTRA_OUTPUT, pcUri); // 指定图片输出地址
        if (mCrop) {
            // 头像要用到裁剪
            startActivityForResult(intent, REQUEST_CODE_CAREMA_CROP);
        }
        else {
            // 相册不需要用到裁剪
            startActivityForResult(intent, REQUEST_CODE_CAREMA);
        }
    }

相册调用 

private void selectPicFromGallery() {
        mOutputFile = getPicFile(getActivity());
        Log.e(TAG,
                "selectPicFromCamera : " + mOutputFile.getPath() + "  "
                        + mOutputFile.exists());
        Intent intent = new Intent(Intent.ACTION_PICK, null);
        intent.setDataAndType(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, "image/*");
        if (mCrop) {
            // 头像需要用到裁剪
            startActivityForResult(intent, REQUEST_CODE_GALLERY_CROP);
        }
        else {
            // 相册不需要用到裁剪
            startActivityForResult(intent, REQUEST_CODE_GALLERY);
        }
    }

裁剪 

private void startCropPicture(File cropPicFile) {
        if (cropPicFile != null && cropPicFile.exists()) {
            final BitmapFactory.Options options = new BitmapFactory.Options();
            options.inJustDecodeBounds = true;
            BitmapFactory.decodeFile(cropPicFile.getPath(), options);
            Log.i("++++2222----DecodeBitmap + " + cropPicFile.getPath(), options.outWidth + "  " + options.outHeight + "  "
                    + options.inSampleSize);
            options.inJustDecodeBounds = false;
            Intent caremaCropintent = new Intent("com.android.camera.action.CROP");// 剪裁
            caremaCropintent.setDataAndType(Uri.fromFile(cropPicFile), "image/*");
            caremaCropintent.putExtra("crop", "true");
            // 设置宽高比例
            caremaCropintent.putExtra("aspectX", 1);
            caremaCropintent.putExtra("aspectY", 1);
            // 设置裁剪图片宽高
            caremaCropintent.putExtra("outputX", mOutputX);
            caremaCropintent.putExtra("outputY", mOutputY);
            caremaCropintent.putExtra("return-data", false);
            caremaCropintent.putExtra("noFaceDetection", false); // no face detection
            caremaCropintent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(mOutputFile));
            caremaCropintent.putExtra("outputFormat",
                    Bitmap.CompressFormat.JPEG.toString());
            startActivityForResult(caremaCropintent, REQUEST_CODE_SELECTED); // 设置裁剪参数显示图片至ImageView
        }
        
    }

图片缩放 

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 (reqWidth <= 0 || reqHeight <= 0 || width <= 0 || height <= 0) {
            return inSampleSize;
        }
        
        if (height > reqHeight || width > reqWidth) {
            
            final int halfHeight = height / 2;
            final int halfWidth = width / 2;
            
            // 在保证解析出的bitmap宽高分别大于目标尺寸宽高的前提下，取可能的inSampleSize的最大值
            while ((halfHeight / inSampleSize) >= reqHeight
                    && (halfWidth / inSampleSize) >= reqWidth) {
                inSampleSize *= 2;
            }
        }
        Log.i("DecodeBitmap", options.outWidth + "  " + options.outHeight + "  "
                + options.inSampleSize);
        
        return inSampleSize;
    }
    
    public static Bitmap decodeSampledBitmapFromResource(Resources res, int resId,
            int reqWidth, int reqHeight, Config config) {
        
        // 首先设置 inJustDecodeBounds=true 来获取图片尺寸
        final BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeResource(res, resId, options);
        
        // 计算 inSampleSize 的值
        options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);
        if (config != null) {
            options.inPreferredConfig = config;
        }
        
        // 根据计算出的 inSampleSize 来解码图片生成Bitmap
        options.inJustDecodeBounds = false;
        return BitmapFactory.decodeResource(res, resId, options);
    }
    
    public static Bitmap decodeSampledBitmapFromFile(String filePath, int reqWidth,
            int reqHeight, Config config) {
        
        // 首先设置 inJustDecodeBounds=true 来获取图片尺寸
        final BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(filePath, options);
        
        // 计算 inSampleSize 的值
        options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);
        if (config != null) {
            options.inPreferredConfig = config;
        }
        
        Log.i("DecodeBitmap", options.outWidth + "  " + options.outHeight + "  "
                + options.inSampleSize);
        
        // 根据计算出的 inSampleSize 来解码图片生成Bitmap
        options.inJustDecodeBounds = false;
        return BitmapFactory.decodeFile(filePath, options);
    }

图片文件压缩 

public static void saveBitmapToFileWithCompress(String picFilePath, Bitmap bitmap) {
        File photoFile = new File(picFilePath); // 在指定路径下创建文件
        FileOutputStream fileOutputStream = null;
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        int scale = 100;
        double baosSize = 0;
        try {
            fileOutputStream = new FileOutputStream(photoFile);
            if (bitmap != null) {
                if (bitmap.compress(Bitmap.CompressFormat.JPEG, scale, baos)) {
                    baosSize = baos.toByteArray().length / 1024;
                    scale -= 20;
                    while (baosSize > 500 && scale > 0) {
                        baos.reset();
                        bitmap.compress(Bitmap.CompressFormat.JPEG, scale, baos);
                        baosSize = baos.toByteArray().length / 1024;
                        scale -= 20;
                    }
                    // 缩放后的数据写入到文件中
                    baos.writeTo(fileOutputStream);
                    fileOutputStream.flush();
                }
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            photoFile.delete();
            e.printStackTrace();
        } finally {
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }


SelectPictureManager封装整个操作

package com.qingqing.base;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import com.qingqing.base.view.dialog.ActionSheetDialog;
import com.qingqing.base.view.dialog.ActionSheetDialog.OnSheetItemClickListener;
import com.qingqing.base.view.dialog.ActionSheetDialog.SheetItemColor;
import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.content.res.Resources;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Bitmap.Config;
import android.net.Uri;
import android.os.Environment;
import android.provider.MediaStore;
import android.support.v4.app.Fragment;
import android.text.TextUtils;
import android.util.Log;

public class SelectPictureManager {
    
    private static final String TAG = "SelectPictureManager";
    
    private static final int REQUEST_CODE_CAREMA = 10001;
    private static final int REQUEST_CODE_CAREMA_CROP = 10002;
    private static final int REQUEST_CODE_GALLERY = 10003;
    private static final int REQUEST_CODE_GALLERY_CROP = 10004;
    private static final int REQUEST_CODE_SELECTED = 10005;
    
    private Activity mActivity;
    private Fragment mFragment;
    
    private boolean mCrop;
    
    private SelectPicListerner mSelectPicListerner;
    
    private int mOutputX;
    private int mOutputY;
    
    private File mOutputFile;
    
    private final boolean mIsFragment;
    
    private int mKey;
    
    public SelectPictureManager(Activity activity) {
        mActivity = activity;
        mIsFragment = false;
    }
    
    public SelectPictureManager(Fragment fragment) {
        mFragment = fragment;
        mIsFragment = true;
    }
    
    public void setSelectPicListerner(SelectPicListerner l) {
        mSelectPicListerner = l;
    }
    
    /** 不裁剪 ，保持原图 */
    public void startSelectPicture() {
        startSelectPicture(-1, 0, 0);
    }
    
    /** 不裁剪 ，保持原图 */
    public void startSelectPicture(int key) {
        startSelectPicture(key, 0, 0);
    }
    
    /** 不裁剪 outputX > 0 and outputY > 0 输出的图按照outputX和outputY来缩放 */
    public void startSelectPicture(int outputX, int outputY) {
        startSelectPicture(-1, false, outputX, outputY);
    }
    
    /** 不裁剪 outputX > 0 and outputY > 0 输出的图按照outputX和outputY来缩放 */
    public void startSelectPicture(int key, int outputX, int outputY) {
        startSelectPicture(key, false, outputX, outputY);
    }
    
    public void startSelectPicture(boolean crop, int outputX, int outputY) {
        startSelectPicture(-1, crop, outputX, outputY);
    }
    
    public void startSelectPicture(int key, boolean crop, int outputX, int outputY) {
        mKey = key;
        mCrop = crop;
        mOutputX = outputX;
        mOutputY = outputY;
        final Activity activity = getActivity();
        if (activity != null) {
            new ActionSheetDialog(activity)
                    .builder()
                    .setCancelable(true)
                    .setCanceledOnTouchOutside(true)
                    .addSheetItem("拍照", SheetItemColor.Gray,
                            new OnSheetItemClickListener() {
                                
                                @Override
                                public void onClick(int which) {
                                    selectPicFromCamera();
                                }
                            })
                    .addSheetItem("去相册选择", SheetItemColor.Gray,
                            new OnSheetItemClickListener() {
                                
                                @Override
                                public void onClick(int which) {
                                    selectPicFromGallery();
                                }
                            }).show();
            
        }
    }
    
    private void startCropPicture(File cropPicFile) {
        if (cropPicFile != null && cropPicFile.exists()) {
            final BitmapFactory.Options options = new BitmapFactory.Options();
            options.inJustDecodeBounds = true;
            BitmapFactory.decodeFile(cropPicFile.getPath(), options);
            Log.i("++++2222----DecodeBitmap + " + cropPicFile.getPath(), options.outWidth + "  " + options.outHeight + "  "
                    + options.inSampleSize);
            options.inJustDecodeBounds = false;
            Intent caremaCropintent = new Intent("com.android.camera.action.CROP");// 剪裁
            caremaCropintent.setDataAndType(Uri.fromFile(cropPicFile), "image/*");
            caremaCropintent.putExtra("crop", "true");
            // 设置宽高比例
            caremaCropintent.putExtra("aspectX", 1);
            caremaCropintent.putExtra("aspectY", 1);
            // 设置裁剪图片宽高
            caremaCropintent.putExtra("outputX", mOutputX);
            caremaCropintent.putExtra("outputY", mOutputY);
            caremaCropintent.putExtra("return-data", false);
            caremaCropintent.putExtra("noFaceDetection", false); // no face detection
            caremaCropintent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(mOutputFile));
            caremaCropintent.putExtra("outputFormat",
                    Bitmap.CompressFormat.JPEG.toString());
            startActivityForResult(caremaCropintent, REQUEST_CODE_SELECTED); // 设置裁剪参数显示图片至ImageView
        }
        
    }
    
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        Log.e(TAG, "requestCode = " + requestCode + "  |   resultCode = " + resultCode);
        final Activity activity = mIsFragment ? mFragment.getActivity() : mActivity;
        if (activity == null) {
            return;
        }
        if (resultCode != Activity.RESULT_OK) {
            return;
        }
        switch (requestCode) {
            case REQUEST_CODE_GALLERY:
                File selectedPicFile = getSelectedPicFileFromGallery(data);
                if (mOutputX > 0 && mOutputY > 0) {
                    if (selectedPicFile != null && selectedPicFile.exists()
                            && mOutputFile != null && mOutputFile.exists()) {
                        Bitmap b = decodeSampledBitmapFromFile(selectedPicFile.getPath(),
                                mOutputX, mOutputY, Config.ARGB_4444);
                        Log.i(TAG, "save before" + selectedPicFile.length()
                                / (double) 1024);
                        saveBitmapToFileWithCompress(mOutputFile.getPath(), b);
                        if (b != null && !b.isRecycled()) {
                            b.recycle();
                        }
                        Log.i(TAG, "save after" + mOutputFile.length() / (double) 1024);
                        notifyPicSelected(mOutputFile);
                    }
                }
                else {
                    if (selectedPicFile != null && selectedPicFile.exists()) {
                        notifyPicSelected(selectedPicFile);
                    }
                }
                break;
            case REQUEST_CODE_GALLERY_CROP:
                startCropPicture(getSelectedPicFileFromGallery(data));
                break;
            case REQUEST_CODE_CAREMA_CROP:
                startCropPicture(mOutputFile);
                break;
            case REQUEST_CODE_CAREMA:
                if (mOutputX > 0 && mOutputY > 0) {
                    if (mOutputFile != null && mOutputFile.exists()
                            && mOutputFile != null && mOutputFile.exists()) {
                        Bitmap b = decodeSampledBitmapFromFile(mOutputFile.getPath(),
                                mOutputX, mOutputY, Config.ARGB_4444);
                        Log.i(TAG, "save before" + mOutputFile.length() / (double) 1024);
                        saveBitmapToFileWithCompress(mOutputFile.getPath(), b);
                        if (b != null && !b.isRecycled()) {
                            b.recycle();
                        }
                        Log.i(TAG, "save after" + mOutputFile.length() / (double) 1024);
                        notifyPicSelected(mOutputFile);
                    }
                }
                else {
                    if (mOutputFile != null && mOutputFile.exists()) {
                        notifyPicSelected(mOutputFile);
                    }
                }
                break;
            case REQUEST_CODE_SELECTED:
                if (mOutputFile != null && mOutputFile.exists()) {
                    final BitmapFactory.Options options = new BitmapFactory.Options();
                    options.inJustDecodeBounds = true;
                    BitmapFactory.decodeFile(mOutputFile.getPath(), options);
                    Log.i("++++DecodeBitmap", options.outWidth + "  " + options.outHeight + "  "
                            + options.inSampleSize);
                    options.inJustDecodeBounds = false;
                    notifyPicSelected(mOutputFile);
                }
                break;
            default:
                break;
        }
    }
    
    private Activity getActivity() {
        return mIsFragment ? mFragment.getActivity() : mActivity;
    }
    
    private File getSelectedPicFileFromGallery(Intent data) {
        final Activity activity = getActivity();
        if (data != null && activity != null) {
            Uri selectedImage = data.getData();
            String[] filePathColumns = { MediaStore.Images.Media.DATA };
            Cursor c = activity.getContentResolver().query(selectedImage,
                    filePathColumns, null, null, null);
            String picPath = null;
            if (c.getCount() > 0) {
                c.moveToFirst();
                int columnIndex = c.getColumnIndex(filePathColumns[0]);
                picPath = c.getString(columnIndex);
                c.close();
            }
            if (!TextUtils.isEmpty(picPath)) {
                File file = new File(picPath);
                return file;
            }
        }
        return null;
    }
    
    private void selectPicFromGallery() {
        mOutputFile = getPicFile(getActivity());
        Log.e(TAG,
                "selectPicFromCamera : " + mOutputFile.getPath() + "  "
                        + mOutputFile.exists());
        Intent intent = new Intent(Intent.ACTION_PICK, null);
        intent.setDataAndType(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, "image/*");
        if (mCrop) {
            // 头像需要用到裁剪
            startActivityForResult(intent, REQUEST_CODE_GALLERY_CROP);
        }
        else {
            // 相册不需要用到裁剪
            startActivityForResult(intent, REQUEST_CODE_GALLERY);
        }
    }
    
    private void selectPicFromCamera() {
        mOutputFile = getPicFile(getActivity());
        Log.e(TAG,
                "selectPicFromGallery : " + mOutputFile.getPath() + "  "
                        + mOutputFile.exists());
        Uri pcUri = Uri.fromFile(mOutputFile);
        Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
        intent.putExtra(MediaStore.EXTRA_OUTPUT, pcUri); // 指定图片输出地址
        if (mCrop) {
            // 头像要用到裁剪
            startActivityForResult(intent, REQUEST_CODE_CAREMA_CROP);
        }
        else {
            // 相册不需要用到裁剪
            startActivityForResult(intent, REQUEST_CODE_CAREMA);
        }
    }
    
    private void startActivityForResult(Intent intent, int requestCode) {
        if (mIsFragment) {
            mFragment.startActivityForResult(intent, requestCode);
        }
        else {
            mActivity.startActivityForResult(intent, requestCode);
        }
    }
    
    private String getDefaultPicFileName() {
        return System.currentTimeMillis() + ".jpg";
    }
    
    private File getPicFile(Context context) {
        File file = new File(getPicDirs(context), getDefaultPicFileName());
        if (!file.exists()) {
            try {
                file.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return file;
    }
    
    private File getPicDirs(Context context) {
        if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
            File dirs = new File(Environment.getExternalStorageDirectory()
                    + "/qingqing/temp_camera/");
            if (!dirs.exists()) {
                dirs.mkdirs();
            }
            return dirs;
        }
        else {
            String filePath = context.getFilesDir().getParent();
            if (!TextUtils.isEmpty(filePath)
                    && filePath.charAt(filePath.length() - 1) == '/') {
                filePath = filePath.substring(0, filePath.length() - 1);
            }
            File dirs = new File(filePath + "/qingqing/temp_camera/");
            if (!dirs.exists()) {
                dirs.mkdirs();
            }
            return dirs;
        }
    }
    
    public void destroy() {
        mActivity = null;
        mFragment = null;
        setSelectPicListerner(null);
    }
    
    private void notifyPicSelected(File outputFile) {
        if (mSelectPicListerner != null) {
            mSelectPicListerner.onPicSelected(mKey, outputFile);
        }
    }
    
    public interface SelectPicListerner {
        public void onPicSelected(int key, File outputFile);
    }
    
    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 (reqWidth <= 0 || reqHeight <= 0 || width <= 0 || height <= 0) {
            return inSampleSize;
        }
        
        if (height > reqHeight || width > reqWidth) {
            
            final int halfHeight = height / 2;
            final int halfWidth = width / 2;
            
            // 在保证解析出的bitmap宽高分别大于目标尺寸宽高的前提下，取可能的inSampleSize的最大值
            while ((halfHeight / inSampleSize) >= reqHeight
                    && (halfWidth / inSampleSize) >= reqWidth) {
                inSampleSize *= 2;
            }
        }
        Log.i("DecodeBitmap", options.outWidth + "  " + options.outHeight + "  "
                + options.inSampleSize);
        
        return inSampleSize;
    }
    
    public static Bitmap decodeSampledBitmapFromResource(Resources res, int resId,
            int reqWidth, int reqHeight, Config config) {
        
        // 首先设置 inJustDecodeBounds=true 来获取图片尺寸
        final BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeResource(res, resId, options);
        
        // 计算 inSampleSize 的值
        options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);
        if (config != null) {
            options.inPreferredConfig = config;
        }
        
        // 根据计算出的 inSampleSize 来解码图片生成Bitmap
        options.inJustDecodeBounds = false;
        return BitmapFactory.decodeResource(res, resId, options);
    }
    
    public static Bitmap decodeSampledBitmapFromFile(String filePath, int reqWidth,
            int reqHeight, Config config) {
        
        // 首先设置 inJustDecodeBounds=true 来获取图片尺寸
        final BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(filePath, options);
        
        // 计算 inSampleSize 的值
        options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);
        if (config != null) {
            options.inPreferredConfig = config;
        }
        
        Log.i("DecodeBitmap", options.outWidth + "  " + options.outHeight + "  "
                + options.inSampleSize);
        
        // 根据计算出的 inSampleSize 来解码图片生成Bitmap
        options.inJustDecodeBounds = false;
        return BitmapFactory.decodeFile(filePath, options);
    }
    
    public static void saveBitmapToFileWithCompress(String picFilePath, Bitmap bitmap) {
        File photoFile = new File(picFilePath); // 在指定路径下创建文件
        FileOutputStream fileOutputStream = null;
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        int scale = 100;
        double baosSize = 0;
        try {
            fileOutputStream = new FileOutputStream(photoFile);
            if (bitmap != null) {
                if (bitmap.compress(Bitmap.CompressFormat.JPEG, scale, baos)) {
                    baosSize = baos.toByteArray().length / 1024;
                    scale -= 20;
                    while (baosSize > 500 && scale > 0) {
                        baos.reset();
                        bitmap.compress(Bitmap.CompressFormat.JPEG, scale, baos);
                        baosSize = baos.toByteArray().length / 1024;
                        scale -= 20;
                    }
                    // 缩放后的数据写入到文件中
                    baos.writeTo(fileOutputStream);
                    fileOutputStream.flush();
                }
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            photoFile.delete();
            e.printStackTrace();
        } finally {
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
}

调用流程

相机调用SelectPictureManager


/** 不裁剪 */
mSelectPictureManager.startSelectPicture();
/** 不裁剪  outputX > 0 and outputY > 0*/
mSelectPictureManager。startSelectPicture(int outputX, int outputY);


1.Activity调用
private SelectPictureManager mSelectPictureManager;
在onCreate中
mSelectPictureManager = new SelectPictureManager(this);
mSelectPictureManager.setSelectPicListerner(new SelectPicListerner() {
            
            @Override
            public void onPicSelected(int key, File outputFile) {


            }
        });
在onActivityResult中
if (mSelectPictureManager != null) {
    mSelectPictureManager.onActivityResult(requestCode, resultCode, data);
}


在onDestory中
mSelectPictureManager.destroy();
mSelectPictureManager = null;


2.Fragment调用
private SelectPictureManager mSelectPictureManager;
在onViewCreated中
mSelectPictureManager = new SelectPictureManager(this);
mSelectPictureManager.setSelectPicListerner(new SelectPicListerner() {
            
            @Override
            public void onPicSelected(int key, File outputFile) {


            }
});


在onActivityResult中
if (mSelectPictureManager != null) {
    mSelectPictureManager.onActivityResult(requestCode, resultCode, data);
}


在onDestroyView中
mSelectPictureManager.destroy();
mSelectPictureManager = null;

whuthm
关注
专栏目录
Android调用系统图库和相机获取图片并裁剪
m0_37930105的博客
08-02 1万+
1、获取权限   2、点击按钮来提示选择图库还是相机 private String[]mCustomItems=new String[]{"本地相册","相机拍照"}; //显示选择相机，图库对话框 private void showDialogCustom(){ //创建对话框 AlertDialog.Builder builde
Android完美调用系统相机、相册以及裁剪功能
Flutter|Android移动开发
03-06 576
在 Android应用中，很多时候我们需要实现上传图片，或者直接调用手机上的拍照功能拍照处理然后直接显示并上传功能，下面将讲述调用相机拍照处理图片然后显示和调用手机相册中的图片处理然后显示的功能，要想实现上传功能，一般都是上传到数据库中，将imageView中的图片取出来然后存到数据库中即可。 下面讲述实现的步骤： 1. 调用相册中的图片裁剪然后显示。 1.1 使用Intent获取从相
Android调用系统相机和相册并裁剪图片
01-20
调用系统相机拍照和相册选择图片,然后裁剪图片
Android调用系统的相机，图库，以及裁剪图片功能。
队长，别开枪，是我！
07-08 1081
在开发中，调用系统的相机拍照，或者图库选择图片是很常见的操作，有时候你会看到有的应用在选择图片的时候，会有个小方框，可以进行图片的裁剪选择，其实，这些都可以通过调用系统来实现。 1：调用系统的相机拍照。 Intent takePictureIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE); if (ta
MASA MAUI Plugin （八）Android相册多选照片（Intent 方式）
dotNET跨平台
02-22 691
背景MAUI的出现，赋予了广大.Net开发者开发多平台应用的能力，MAUI 是Xamarin.Forms演变而来，但是相比Xamarin性能更好，可扩展性更强，结构更简单。但是MAUI对于平台相关的实现并不完整。所以MASA团队开展了一个实验性项目，意在对微软MAUI的补充和扩展项目地址https://github.com/BlazorComponent/MASA.Blazor/tree/feat...
Android 图像系列： 图片的裁剪与相机调用
k
11-08 5619
有时候我们需要的图片并不适合我们想要的大小， 那么我们就可以用到系统自带的图片裁剪功能， 把规定范围的图像给剪出来。     贴上部分代码：   //调用图库 Intent intent = new Intent(); intent.setType("image/*"); intent.putExtra("crop", "true"); // crop=true 有这句才能出来最后的裁剪页
Android实现从本地图库/相机拍照后裁剪图片并设置头像
09-02
在Android应用开发中，用户经常需要设置个性化头像，这通常涉及到从本地图库选取图片或使用相机拍摄照片，然后进行裁剪以适应特定尺寸的需求。以下是一个详细讲解如何实现这个功能的过程： 首先，我们需要创建一个...
Android高级应用源码-android 调用系统相机图库裁剪-图片上传-客服端(测试可用).zip
12-17
这份"Android高级应用源码-android 调用系统相机图库裁剪-图片上传-客服端(测试可用).zip"的资源提供了完整的实现示例，可以帮助开发者更好地理解和运用这些技术。 1. **调用系统相机**： Android系统提供了一个...
Android + <调用相机拍照 & 选择相册> + 数码相机
最新发布
04-27
【TakePicture】项目分为两大部分...实测：android 8、9、10、11、13以及鸿蒙系统有效。 机型：小米、OPPO、VIVO、华为手机。 1. 上传头像并裁剪。 2. 上传多张照片并做压缩处理，图片可实现在线预览，伸缩放大等功能。
android拍照截图组件,Android 相册、拍照选取图片后截图方案
weixin_28862557的博客
05-26 265
一、相册方案1、使用Bitmap并返回数据2、使用Uri不返回数据使用Bitmap有可能会导致图片过大，而不能返回实际大小的图片，我将采用大图Uri，小图Bitmap的数据存储方式。我们将要使用到URI来保存拍照后的图片：privatestaticfinalStringIMAGE_FILE_LOCATION="file:///sdcard/temp.jpg";//tempfileUr...
android 上传Bitmap到服务器端
热门推荐
我的专栏
11-25 1万+
转载于： Last week, I faced a problem to send an image to the server, I have tried a lot of ways, but seemed that nothing would work. After some research, I found the HTTPClient API , this API hel
图片压缩
lyglostangel的专栏
04-20 406
/**      * 计算inSampleSize，用于压缩图片      *      * @param options      * @param reqWidth      * @param reqHeight      * @return      */     public static int calculateInSampleSize(BitmapFactory.Op
intent隐式打开相机相册裁剪
xieyu1999的博客
01-19 333
//相册 Intent intent = new Intent(Intent.ACTION_PICK); intent.setType("image/*"); startActivityForResult(intent, REQUEST_PICK); //相机 Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE); inten...
android 4.3选择图片“无法加载图片问题”
d773689630的专栏
05-19 1355
图片截取失败问题
解决Android图片剪切返回崩溃问题
西西里的木头
12-05 5346
使用系统自带的intent来实现拍照，相册选择图片后剪切功能时，会遇到返回崩溃的问题。 原因是设置如下属性时， intent.putExtra("return-data", true); 通过Intent中的data来传递，当数据过大，即超过1M（经测试，这个数值在不同手机还不一样）时就崩了！！！！ 解决方法是：通过uri来传递，然后在转换成Bitmap。直接上代码： /
Android11 图片裁剪问题
XL_0102的博客
04-25 943
前提须知： 总所周知，Android11之后存储发生变更，APP只能访问自己的私有目录或者公共目录，不能访问别的app的私有目录。 错误原因： 发生“保存时发生错误，保存失败”这个错误的原因是你调用系统自带的裁剪工具不属于你的app，访问你的app私有目录是不允许的。 解决： 裁切intent.putExtra(MediaStore.EXTRA_OUTPUT, uri)这里的uri使用公用目录： File cropPhoto; if(Build.VERSION.SDK_INT >= Build.
关于调用系统摄像头进行拍照和录像的一些问题
Saturation的博客
06-12 783
关于拍照权限问题 AndroidManifest.xml内必配置的 <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" /> <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" /> <uses-permission android:name="android.permission.
Android应用：相机与图库选择功能详解
在Android应用开发中，"Android调用相机图库"这一主题主要涉及了如何在Android应用程序中集成相机功能以及从用户设备的图片库选择图片。以下是一些关键知识点的详细解释： 1. **导入必要的包**： 开始时，开发者...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值