在我的应用程序中，我想从图库中选择图像或从相机捕获图像并上传到服务器。
我想在发送到服务器之前先将此图像调整为以下尺寸:1000 x 600，然后上传。
我的代码:
public class ImageActivity extends AppCompatActivity implements View.OnClickListener {
ImageView imageView;
Button pickImage, upload;
private static final int REQUEST_TAKE_PHOTO = 0;
private static final int REQUEST_PICK_PHOTO = 2;
private Uri mMediaUri;
private static final int CAMERA_PIC_REQUEST = 1111;
private static final String TAG = ImageActivity.class.getSimpleName();
private static final int CAMERA_CAPTURE_IMAGE_REQUEST_CODE = 100;
public static final int MEDIA_TYPE_IMAGE = 1;
private Uri fileUri;
private String mediaPath;
private Button btnCapturePicture;
private String mImageFileLocation = "";
public static final String IMAGE_DIRECTORY_NAME = "Android File Upload";
ProgressDialog pDialog;
private String postPath;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.image_layout);
imageView = (ImageView) findViewById(R.id.preview);
pickImage = (Button) findViewById(R.id.pickImage);
upload = (Button) findViewById(R.id.upload);
pickImage.setOnClickListener(this);
upload.setOnClickListener(this);
initDialog();
}
@Override
public void onClick(final View v) {
switch (v.getId()) {
case R.id.pickImage:
new MaterialDialog.Builder(this)
.title(R.string.uploadImages)
.items(R.array.uploadImages)
.itemsIds(R.array.itemIds)
.itemsCallback(new MaterialDialog.ListCallback() {
@Override
public void onSelection(MaterialDialog dialog, View view, int which, CharSequence text) {
switch (which) {
case 0:
Intent galleryIntent = new Intent(Intent.ACTION_PICK,
android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
startActivityForResult(galleryIntent, REQUEST_PICK_PHOTO);
break;
case 1:
captureImage();
break;
case 2:
imageView.setImageResource(R.drawable.ic_launcher_background);
break;
}
}
})
.show();
break;
case R.id.upload:
uploadFile();
break;
}
}
private boolean isExternalStorageAvailable() {
String state = Environment.getExternalStorageState();
if (Environment.MEDIA_MOUNTED.equals(state)) {
return true;
} else {
return false;
}
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
if (resultCode == RESULT_OK) {
if (requestCode == REQUEST_TAKE_PHOTO || requestCode == REQUEST_PICK_PHOTO) {
if (data != null) {
// Get the Image from data
Uri selectedImage = data.getData();
String[] filePathColumn = {MediaStore.Images.Media.DATA};
Cursor cursor = getContentResolver().query(selectedImage, filePathColumn, null, null, null);
assert cursor != null;
cursor.moveToFirst();
int columnIndex = cursor.getColumnIndex(filePathColumn[0]);
mediaPath = cursor.getString(columnIndex);
// Set the Image in ImageView for Previewing the Media
Bitmap bitmapImage = BitmapFactory.decodeFile(mediaPath);
imageView.setImageBitmap(bitmapImage);
cursor.close();
postPath = mediaPath;
}
} else if (requestCode == CAMERA_PIC_REQUEST) {
if (Build.VERSION.SDK_INT > 21) {
Glide.with(this).load(mImageFileLocation).into(imageView);
postPath = mImageFileLocation;
} else {
Glide.with(this).load(fileUri).into(imageView);
postPath = fileUri.getPath();
}
}
} else if (resultCode != RESULT_CANCELED) {
Toast.makeText(this, "Sorry, there was an error!", Toast.LENGTH_LONG).show();
}
}
/**
* Checking device has camera hardware or not
*/
private boolean isDeviceSupportCamera() {
if (getApplicationContext().getPackageManager().hasSystemFeature(
PackageManager.FEATURE_CAMERA)) {
// this device has a camera
return true;
} else {
// no camera on this device
return false;
}
}
protected void initDialog() {
pDialog = new ProgressDialog(this);
pDialog.setMessage(getString(R.string.msg_loading));
pDialog.setCancelable(true);
}
protected void showpDialog() {
if (!pDialog.isShowing()) pDialog.show();
}
protected void hidepDialog() {
if (pDialog.isShowing()) pDialog.dismiss();
}
/**
* Launching camera app to capture image
*/
private void captureImage() {
if (Build.VERSION.SDK_INT > 21) { //use this if Lollipop_Mr1 (API 22) or above
Intent callCameraApplicationIntent = new Intent();
callCameraApplicationIntent.setAction(MediaStore.ACTION_IMAGE_CAPTURE);
// We give some instruction to the intent to save the image
File photoFile = null;
try {
// If the createImageFile will be successful, the photo file will have the address of the file
photoFile = createImageFile();
// Here we call the function that will try to catch the exception made by the throw function
} catch (IOException e) {
Logger.getAnonymousLogger().info("Exception error in generating the file");
e.printStackTrace();
}
// Here we add an extra file to the intent to put the address on to. For this purpose we use the FileProvider, declared in the AndroidManifest.
Uri outputUri = FileProvider.getUriForFile(
this,
BuildConfig.APPLICATION_ID + ".provider",
photoFile);
callCameraApplicationIntent.putExtra(MediaStore.EXTRA_OUTPUT, outputUri);
// The following is a new line with a trying attempt
callCameraApplicationIntent.addFlags(Intent.FLAG_GRANT_WRITE_URI_PERMISSION | Intent.FLAG_GRANT_READ_URI_PERMISSION);
Logger.getAnonymousLogger().info("Calling the camera App by intent");
// The following strings calls the camera app and wait for his file in return.
startActivityForResult(callCameraApplicationIntent, CAMERA_PIC_REQUEST);
} else {
Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
fileUri = getOutputMediaFileUri(MEDIA_TYPE_IMAGE);
intent.putExtra(MediaStore.EXTRA_OUTPUT, fileUri);
// start the image capture Intent
startActivityForResult(intent, CAMERA_PIC_REQUEST);
}
}
File createImageFile() throws IOException {
Logger.getAnonymousLogger().info("Generating the image - method started");
// Here we create a "non-collision file name", alternatively said, "an unique filename" using the "timeStamp" functionality
String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmSS").format(new Date());
String imageFileName = "IMAGE_" + timeStamp;
// Here we specify the environment location and the exact path where we want to save the so-created file
File storageDirectory = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES + "/photo_saving_app");
Logger.getAnonymousLogger().info("Storage directory set");
// Then we create the storage directory if does not exists
if (!storageDirectory.exists()) storageDirectory.mkdir();
// Here we create the file using a prefix, a suffix and a directory
File image = new File(storageDirectory, imageFileName + ".jpg");
// File image = File.createTempFile(imageFileName, ".jpg", storageDirectory);
// Here the location is saved into the string mImageFileLocation
Logger.getAnonymousLogger().info("File name and path set");
mImageFileLocation = image.getAbsolutePath();
// fileUri = Uri.parse(mImageFileLocation);
// The file is returned to the previous intent across the camera application
return image;
}
/**
* Here we store the file url as it will be null after returning from camera
* app
*/
@Override
protected void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
// save file url in bundle as it will be null on screen orientation
// changes
outState.putParcelable("file_uri", fileUri);
}
@Override
protected void onRestoreInstanceState(Bundle savedInstanceState) {
super.onRestoreInstanceState(savedInstanceState);
// get the file url
fileUri = savedInstanceState.getParcelable("file_uri");
}
/**
* Receiving activity result method will be called after closing the camera
* */
/**
* ------------ Helper Methods ----------------------
* */
/**
* Creating file uri to store image/video
*/
public Uri getOutputMediaFileUri(int type) {
return Uri.fromFile(getOutputMediaFile(type));
}
/**
* returning image / video
*/
private static File getOutputMediaFile(int type) {
// External sdcard location
File mediaStorageDir = new File(
Environment
.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES),
IMAGE_DIRECTORY_NAME);
// Create the storage directory if it does not exist
if (!mediaStorageDir.exists()) {
if (!mediaStorageDir.mkdirs()) {
Log.d(TAG, "Oops! Failed create "
+ IMAGE_DIRECTORY_NAME + " directory");
return null;
}
}
// Create a media file name
String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss",
Locale.getDefault()).format(new Date());
File mediaFile;
if (type == MEDIA_TYPE_IMAGE) {
mediaFile = new File(mediaStorageDir.getPath() + File.separator
+ "IMG_" + ".jpg");
} else {
return null;
}
return mediaFile;
}
// Uploading Image/Video
private void uploadFile() {
if (postPath == null || postPath.equals("")) {
Toast.makeText(this, "please select an image ", Toast.LENGTH_LONG).show();
return;
} else {
showpDialog();
// Map is used to multipart the file using okhttp3.RequestBody
Map<String, RequestBody> map = new HashMap<>();
File file = new File(postPath);
// Parsing any Media type file
RequestBody requestBody = RequestBody.create(MediaType.parse("*/*"), file);
map.put("file\"; filename=\"" + file.getName() + "\"", requestBody);
ApiConfig getResponse = AppConfig.getRetrofit().create(ApiConfig.class);
Call<ServerResponse> call = getResponse.upload("token", map);
call.enqueue(new Callback<ServerResponse>() {
@Override
public void onResponse(Call<ServerResponse> call, Response<ServerResponse> response) {
if (response.isSuccessful()) {
if (response.body() != null) {
hidepDialog();
ServerResponse serverResponse = response.body();
Toast.makeText(getApplicationContext(), serverResponse.getMessage(), Toast.LENGTH_SHORT).show();
}
} else {
hidepDialog();
Toast.makeText(getApplicationContext(), "problem uploading image", Toast.LENGTH_SHORT).show();
}
}
@Override
public void onFailure(Call<ServerResponse> call, Throwable t) {
hidepDialog();
Log.v("Response gotten is", t.getMessage());
}
});
}
}
我该怎么做？
最佳答案
试试这个类(class)
图像压缩.java
public class ImageCompression {
private static final String LOG_TAG = ImageCompression.class.getSimpleName();
static volatile ImageCompression singleton = null;
private static Context mContext;
public ImageCompression(Context context) {
mContext = context;
}
/**
* Initialise the class and set the context
*/
public static ImageCompression with(Context context) {
if (singleton == null) {
synchronized (ImageCompression.class) {
if (singleton == null) {
singleton = new Builder(context).build();
}
}
}
return singleton;
}
/**
* Compresses the image at the specified Uri String and and return the filepath of the compressed image.
*
* @param imageUri imageUri Uri (String) of the source image you wish to compress
* @return filepath
*/
public String compress(String imageUri) {
return compressImage(imageUri, destinationFile());
}
/**
* Compresses the image at the specified Uri String and and return the filepath of the compressed image.
*
* @param imageUri imageUri Uri (String) of the source image you wish to compress
* @return filepath
*/
public String compress(String imageUri, boolean deleteSourceImage) {
String compressUri = compress(imageUri);
if (deleteSourceImage) {
File source = new File(getRealPathFromURI(imageUri));
if (source.exists()) {
boolean isdeleted = source.delete();
Log.e(LOG_TAG, (isdeleted) ? "SourceImage File deleted" : "SourceImage File not deleted");
}
}
return compressUri;
}
public String compress(int drawableID) throws IOException {
// Create a bitmap from this drawable
Bitmap bitmap = BitmapFactory.decodeResource(mContext.getApplicationContext().getResources(), drawableID);
if (null != bitmap) {
// Create a file from the bitmap
// Create an image file name
String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss", Locale.ENGLISH).format(new Date());
String imageFileName = "JPEG_" + timeStamp + "_";
File storageDir = Environment.getExternalStoragePublicDirectory(
Environment.DIRECTORY_PICTURES);
File image = File.createTempFile(
imageFileName, /* prefix */
".jpg", /* suffix */
storageDir /* directory */
);
FileOutputStream out = new FileOutputStream(image);
bitmap.compress(Bitmap.CompressFormat.JPEG, 100, out);
// Compress the new file
Uri copyImageUri = Uri.fromFile(image);
String compressImagePath = compressImage(copyImageUri.toString(), new File(Environment.getExternalStorageDirectory(), "ImageCompression/images"));
// Delete the file create from the drawable Id
if (image.exists()) {
boolean isdeleted = image.delete();
Log.e(LOG_TAG, (isdeleted) ? "SourceImage File deleted" : "SourceImage File not deleted");
}
// return the path to the compress image
return compressImagePath;
}
return null;
}
/**
* Compresses the image at the specified Uri String and and return the bitmap data of the compressed image.
*
* @param imageUri imageUri Uri (String) of the source image you wish to compress
* @return Bitmap format of the new image file (compressed)
* @throws IOException
*/
public Bitmap getCompressBitmap(String imageUri) throws IOException {
File imageFile = new File(compressImage(imageUri, new File(Environment.getExternalStorageDirectory(), "ImageCompression/images")));
Uri newImageUri = Uri.fromFile(imageFile);
Bitmap bitmap = MediaStore.Images.Media.getBitmap(mContext.getContentResolver(), newImageUri);
return bitmap;
}
/**
* Compresses the image at the specified Uri String and and return the bitmap data of the compressed image.
*
* @param imageUri Uri (String) of the source image you wish to compress
* @param deleteSourceImage If True will delete the source file
* @return Compress image bitmap
* @throws IOException
*/
public Bitmap getCompressBitmap(String imageUri, boolean deleteSourceImage) throws IOException {
File imageFile = new File(compressImage(imageUri, new File(Environment.getExternalStorageDirectory(), "ImageCompression/images")));
Uri newImageUri = Uri.fromFile(imageFile);
Bitmap bitmap = MediaStore.Images.Media.getBitmap(mContext.getContentResolver(), newImageUri);
if (deleteSourceImage) {
File source = new File(getRealPathFromURI(imageUri));
if (source.exists()) {
boolean isdeleted = source.delete();
Log.e(LOG_TAG, (isdeleted) ? "SourceImage File deleted" : "SourceImage File not deleted");
}
}
return bitmap;
}
/**
* Do the actual compression of this image
*
* @param imageUri source image file to compress
* @param destDirectory destination directory to place image in
* @return uri string of the compressed image
*/
private String compressImage(String imageUri, File destDirectory) {
String filePath = getRealPathFromURI(imageUri);
Bitmap scaledBitmap = null;
BitmapFactory.Options options = new BitmapFactory.Options();
//by setting this field as true, the actual bitmap pixels are not loaded in the memory. Just the bounds are loaded. If
//you try the use the bitmap here, you will get null.
options.inJustDecodeBounds = true;
Bitmap bmp = BitmapFactory.decodeFile(filePath, options);
//max Height and width values of the compressed image is taken as 816x612
float maxHeight = 1280.0f;//816.0f;
float maxWidth = 1280.0f;//612.0f;
//width and height values are set maintaining the aspect ratio of the image
int actualHeight = options.outHeight;
int actualWidth = options.outWidth;
float imgRatio = (float) actualWidth / (float) actualHeight;
float maxRatio = maxWidth / maxHeight;
if (actualHeight > maxHeight || actualWidth > maxWidth) {
if (imgRatio < maxRatio) {
imgRatio = maxHeight / actualHeight;
actualWidth = (int) (imgRatio * actualWidth);
actualHeight = (int) maxHeight;
} else if (imgRatio > maxRatio) {
imgRatio = maxWidth / actualWidth;
actualHeight = (int) (imgRatio * actualHeight);
actualWidth = (int) maxWidth;
} else {
actualHeight = (int) maxHeight;
actualWidth = (int) maxWidth;
}
}
//setting inSampleSize value allows to load a scaled down version of the original image
options.inSampleSize = calculateInSampleSize(options, actualWidth, actualHeight);
//inJustDecodeBounds set to false to load the actual bitmap
options.inJustDecodeBounds = false;
//this options allow android to claim the bitmap memory if it runs low on memory
options.inPurgeable = true;
options.inInputShareable = true;
options.inTempStorage = new byte[16 * 1024];
try {
//load the bitmap from its path
bmp = BitmapFactory.decodeFile(filePath, options);
} catch (OutOfMemoryError exception) {
exception.printStackTrace();
}
try {
scaledBitmap = Bitmap.createBitmap(actualWidth, actualHeight, Bitmap.Config.ARGB_8888);
} catch (OutOfMemoryError exception) {
exception.printStackTrace();
} /*catch (Exception e) {
e.printStackTrace();
}*/
float ratioX = actualWidth / (float) options.outWidth;
float ratioY = actualHeight / (float) options.outHeight;
float middleX = actualWidth / 2.0f;
float middleY = actualHeight / 2.0f;
Matrix scaleMatrix = new Matrix();
scaleMatrix.setScale(ratioX, ratioY, middleX, middleY);
Canvas canvas = new Canvas(scaledBitmap);
canvas.setMatrix(scaleMatrix);
canvas.drawBitmap(bmp, middleX - bmp.getWidth() / 2, middleY - bmp.getHeight() / 2, new Paint(Paint.FILTER_BITMAP_FLAG));
//check the rotation of the image and display it properly
ExifInterface exif;
try {
exif = new ExifInterface(filePath);
int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, 0);
Log.e("EXIF", "Exif: " + orientation);
Matrix matrix = new Matrix();
if (orientation == 6) {
matrix.postRotate(90);
Log.e("EXIF", "Exif: " + orientation);
} else if (orientation == 3) {
matrix.postRotate(180);
Log.e("EXIF", "Exif: " + orientation);
} else if (orientation == 8) {
matrix.postRotate(270);
Log.e("EXIF", "Exif: " + orientation);
}
scaledBitmap = Bitmap.createBitmap(scaledBitmap, 0, 0, scaledBitmap.getWidth(), scaledBitmap.getHeight(), matrix, true);
} catch (IOException e) {
e.printStackTrace();
}
FileOutputStream out = null;
String filename = getFilename(imageUri, destDirectory);
try {
out = new FileOutputStream(filename);
//write the compressed bitmap at the destination specified by filename.
scaledBitmap.compress(Bitmap.CompressFormat.JPEG, 80, out);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
return filename;
}
private 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 = Math.round((float) height / (float) reqHeight);
final int widthRatio = Math.round((float) width / (float) reqWidth);
inSampleSize = heightRatio < widthRatio ? heightRatio : widthRatio;
}
final float totalPixels = width * height;
final float totalReqPixelsCap = reqWidth * reqHeight * 2;
while (totalPixels / (inSampleSize * inSampleSize) > totalReqPixelsCap) {
inSampleSize++;
}
return inSampleSize;
}
private String getFilename(String filename, File file) {
if (!file.exists()) {
file.mkdirs();
}
String ext = ".jpg";
//get extension
/*if (Pattern.matches("^[.][p][n][g]", filename)){
ext = ".png";
}*/
return (file.getAbsolutePath() + "/IMG_" + new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date()) + ext);
}
/**
* Gets a valid path from the supply contentURI
*
* @param contentURI
* @return A validPath of the image
*/
private String getRealPathFromURI(String contentURI) {
Uri contentUri = Uri.parse(contentURI);
Cursor cursor = mContext.getContentResolver().query(contentUri, null, null, null, null);
if (cursor == null) {
return contentUri.getPath();
} else {
cursor.moveToFirst();
int index = cursor.getColumnIndex(MediaStore.Images.ImageColumns.DATA);
String str = cursor.getString(index);
cursor.close();
return str;
}
// return FileUtils.getPath(mContext, contentUri);
// return getRealPathFromURI_API19(mContext, contentUri);
}
@SuppressLint("NewApi")
public static String getRealPathFromURI_API19(Context context, Uri uri) {
String filePath = "";
String wholeID = DocumentsContract.getDocumentId(uri);
// Split at colon, use second item in the array
String id = wholeID.split(":")[1];
String[] column = {MediaStore.Images.Media.DATA};
// where id is equal to
String sel = MediaStore.Images.Media._ID + "=?";
Cursor cursor = context.getContentResolver().query(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, column, sel, new String[]{id}, null);
int columnIndex = cursor.getColumnIndex(column[0]);
if (cursor.moveToFirst()) {
filePath = cursor.getString(columnIndex);
}
cursor.close();
return filePath;
}
/**
* Fluent API for creating {@link ImageCompression} instances.
*/
public static class Builder {
private final Context context;
/**
* Start building a new {@link ImageCompression} instance.
*/
public Builder(Context context) {
if (context == null) {
throw new IllegalArgumentException("Context must not be null.");
}
this.context = context.getApplicationContext();
}
/**
* Create the {@link ImageCompression} instance.
*/
public ImageCompression build() {
Context context = this.context;
return new ImageCompression(context);
}
}
public File destinationFile() {
File mediaStorageDir = new File(Environment.getExternalStorageDirectory()
+ "/Android/data/"
+ mContext.getPackageName()
+ "/Image/Compressed");
if (!mediaStorageDir.exists())
mediaStorageDir.mkdir();
return mediaStorageDir;
}
/*boolean isCompressSuccess = false;
public String compressVideo(final String videoFilePath) throws URISyntaxException {
final String destinationPath = destinationFile().getAbsolutePath();
isCompressSuccess = MediaController.getInstance().convertVideo(videoFilePath, destinationPath);
if(isCompressSuccess)
return destinationPath;
else
return "";
}*/
public void deleteFiles() {
try
{
new AsyncTask()
{
@Override
protected Object doInBackground(Object[] objects)
{
File mediaStorageDir = new File(Environment.getExternalStorageDirectory()
+ "/Android/data/"
+ mContext.getPackageName()
+ "/Image/Compressed");
if (mediaStorageDir.listFiles() != null && mediaStorageDir.listFiles().length > 0) {
for (File file : mediaStorageDir.listFiles())
if (!file.isDirectory()) {
//file.delete();
}
}
return null;
}
}.execute();
} catch (Exception e) {
e.printStackTrace();
}
}
}
像这样传递参数
String filePath =ImageCompression.with(getApplicationContext()).compress(imagePath.toString(), false);
File file = new File(filePath);
关于java - 从图库中选择图像后如何调整图像大小？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/50578263/