Android 如何在上传之前压缩图像大小这是我的代码

如何在上传之前压缩图像大小这是我的代码 我想在上传到WordPress网站之前压缩图片大小 我在android应用程序中使用WordPress rest API 如何在上传之前压缩图像大小这是我的代码 我想在上传到WordPress网站之前压缩图片大小 我在android应用程序中使用WordPress rest API

// getting images selected from gallery for post and sending them to server
        @Override
        public void onActivityResult(int requestCode, int resultCode, Intent data) {
    // super.onActivityResult(requestCode, resultCode, data);
            switch (requestCode) {
                case FilePickerConst.REQUEST_CODE_PHOTO:
                    if (resultCode == Activity.RESULT_OK && data != null) {
                        imagePaths = new ArrayList<>();
                        imageRequestCount = 1;
                        imagePaths.addAll(data.getStringArrayListExtra(FilePickerConst.KEY_SELECTED_MEDIA));
                        if (SettingsMain.isConnectingToInternet(context)) {
                            if (imagePaths.size() > 0) {
                                btnSelectPix.setEnabled(false);
                                AsyncImageTask asyncImageTask = new AsyncImageTask();
                                asyncImageTask.execute(imagePaths);
                            }
                        }
                    } else {
                        btnSelectPix.setEnabled(true);
                        Toast.makeText(context, settingsMain.getAlertDialogMessage("internetMessage"), Toast.LENGTH_SHORT).show();
                    }
                    break;
            }
        }

        private void adforest_uploadImages(List<MultipartBody.Part> parts) {
            Log.d("info image parts", parts.toString());
            String ad_id = Integer.toString(addId);
            RequestBody adID =
                    RequestBody.create(
                            okhttp3.MultipartBody.FORM, ad_id);
            Log.d("info SendImage", addId + "");
            final Call<ResponseBody> req = restService.postUploadImage(adID, parts, UrlController.UploadImageAddHeaders(context));

            req.enqueue(new Callback<ResponseBody>() {
                @Override
                public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {

                    if (response.isSuccessful()) {

                        Log.v("info Upload", response.toString());
                        JSONObject responseobj = null;
                        try {
                            responseobj = new JSONObject(response.body().string());
                            Log.d("info UploadImage object", "" + responseobj.getJSONObject("data").toString());
                            if (responseobj.getBoolean("success")) {

                                adforest_updateImages(responseobj.getJSONObject("data"));

                                int selectedImageSize = imagePaths.size();
                                int totalSize = currentSize + selectedImageSize;
                                Log.d("info image2", "muImage" + totalSize + "imagePaths" + totalUploadedImages);
                                if (totalSize == totalUploadedImages) {
                                    adforest_UploadSuccessImage();
                                    imagePaths.clear();
                                    paths.clear();
                                    if (allFile.size() > 0) {
                                        for (File file : allFile) {
                                            if (file.exists()) {
                                                if (file.delete()) {
                                                    Log.d("file Deleted :", file.getPath());
                                                } else {
                                                    Log.d("file not Deleted :", file.getPath());
                                                }
                                            }
                                        }
                                    }
                                }

                            } else {
                                adforest_UploadFailedImage();
                                Toast.makeText(context, responseobj.get("message").toString(), Toast.LENGTH_SHORT).show();
                            }
                        } catch (JSONException e) {
                            adforest_UploadFailedImage();
                            e.printStackTrace();
                        } catch (IOException e) {
                            adforest_UploadFailedImage();
                            e.printStackTrace();
                        }

                        btnSelectPix.setEnabled(true);

                    } else {
                        adforest_UploadFailedImage();
                    }
                }

                @Override
                public void onFailure(Call<ResponseBody> call, Throwable t) {
                    Log.e("info Upload Image Err:", t.toString());

                    if (t instanceof TimeoutException) {
                        adforest_UploadFailedImage();

    //                    adforest_requestForImages();
                    }
                    if (t instanceof SocketTimeoutException) {
                        adforest_UploadFailedImage();
    //                    adforest_requestForImages();
    //
                    } else {
                        adforest_UploadFailedImage();
    //                    adforest_requestForImages();
                    }
                }
            });

        }

        private void adforest_UploadFailedImage() {
            progress_bar.setVisibility(View.GONE);
            loadingLayout.setVisibility(View.GONE);
            Gallary.setVisibility(View.VISIBLE);
            Gallary.setCompoundDrawablesWithIntrinsicBounds(R.drawable.ic_check_circle_black_24dp, 0, 0, 0);
            Gallary.setText("" + 0);
            Gallary.setTextColor(Color.parseColor("#a0a0a0"));
            tv_done.setVisibility(View.VISIBLE);
            tv_done.setTextColor(Color.parseColor("#ff0000"));
            tv_done.setText(progressModel.getFailMessage());
            btnSelectPix.setEnabled(true);
            Toast.makeText(context, progressModel.getFailMessage(), Toast.LENGTH_SHORT).show();

        }

        private void adforest_UploadSuccessImage() {
            progress_bar.setVisibility(View.GONE);
            Gallary.setVisibility(View.VISIBLE);
            loadingLayout.setVisibility(View.GONE);
            Gallary.setCompoundDrawablesWithIntrinsicBounds(R.drawable.ic_check_circle_green_24dp, 0, 0, 0);
            Gallary.setText(totalFiles + "");
            tv_done.setText(progressModel.getSuccessMessage());
            Toast.makeText(context, progressModel.getSuccessMessage(), Toast.LENGTH_SHORT).show();
            btnSelectPix.setEnabled(true);
            tv_done.setTextColor(Color.parseColor("#20a406"));
        }

        private MultipartBody.Part adforestst_prepareFilePart(String fileName, Uri fileUri) {

            File finalFile = new File(SettingsMain.getRealPathFromURI(context, fileUri));
            allFile.add(finalFile);
            // create RequestBody instance from file
            RequestBody requestFile =
                    RequestBody.create(
                            MediaType.parse(getContentResolver().getType(fileUri)),
                            finalFile
                    );
            // MultipartBody.Part is used to send also the actual file name
            return MultipartBody.Part.createFormData(fileName, finalFile.getName(), requestFile);
        }

        private File adforest_rotateImage(String path) {
            File file = null;
            Bitmap bitmap = BitmapFactory.decodeFile(path);
            ExifInterface ei = null;
            try {
                ei = new ExifInterface(path);
            } catch (IOException e) {
                e.printStackTrace();
            }
            int orientation = ei.getAttributeInt(ExifInterface.TAG_ORIENTATION,
                    ExifInterface.ORIENTATION_UNDEFINED);

            Bitmap rotatedBitmap = null;
            switch (orientation) {

                case ExifInterface.ORIENTATION_ROTATE_90:
                    rotatedBitmap = rotateImage(bitmap, 90);
                    break;

                case ExifInterface.ORIENTATION_ROTATE_180:
                    rotatedBitmap = rotateImage(bitmap, 180);
                    break;

                case ExifInterface.ORIENTATION_ROTATE_270:
                    rotatedBitmap = rotateImage(bitmap, 270);
                    break;

                case ExifInterface.ORIENTATION_NORMAL:
                default:
                    rotatedBitmap = bitmap;
            }
            file = new File(getRealPathFromURI(getImageUri(rotatedBitmap)));
            allFile.add(file);
            return file;
        }

        public Uri getImageUri(Bitmap inImage) {
            ByteArrayOutputStream bytes = new ByteArrayOutputStream();
            inImage.compress(Bitmap.CompressFormat.JPEG, 100, bytes);
            String path = MediaStore.Images.Media.insertImage(getContentResolver(), inImage, "Title", null);
            return Uri.parse(path);
        }

        public String getRealPathFromURI(Uri uri) {
            Cursor cursor = getContentResolver().query(uri, null, null, null, null);
            cursor.moveToFirst();
            int idx = cursor.getColumnIndex(MediaStore.Images.ImageColumns.DATA);
            return cursor.getString(idx);
        }


    private class AsyncImageTask extends AsyncTask<ArrayList<String>, Void, List<MultipartBody.Part>> {
            ArrayList<String> imaagesLis = null;
            boolean checkDimensions = true, checkImageSize;

            @SafeVarargs
            @Override
            protected final List<MultipartBody.Part> doInBackground(ArrayList<String>... params) {
                List<MultipartBody.Part> parts = null;
                imaagesLis = params[0];
                totalFiles = imaagesLis.size();
                for (int i = 0; i < imaagesLis.size(); i++) {
                    parts = new ArrayList<>();
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd_HHmmss");
                    String currentDateandTime = sdf.format(new Date());
                    Log.d("info image", currentDateandTime);
                    checkDimensions = true;
                    checkImageSize = true;
                    if (adPostImageModel.getDim_is_show()) {
                        BitmapFactory.Options options = new BitmapFactory.Options();
                        options.inJustDecodeBounds = true;
                        BitmapFactory.decodeFile(imaagesLis.get(i), options);
                        int imageWidth = options.outWidth;
                        int imageHeight = options.outHeight;
                        if (imageHeight > Integer.parseInt(adPostImageModel.getDim_height()) &&
                                imageWidth > Integer.parseInt(adPostImageModel.getDim_width())) {
                            checkDimensions = true;
                        } else {
                            checkDimensions = false;
                            runOnUiThread(() -> Toast.makeText(context, adPostImageModel.getDim_height_message(), Toast.LENGTH_SHORT).show());
                        }
                    }

                    File file = new File(imaagesLis.get(i));
                    long fileSizeInBytes = file.length();
                    Integer fileSizeBytes = Math.round(fileSizeInBytes);
                    if (fileSizeBytes > Integer.parseInt(adPostImageModel.getImg_size())) {
                        checkImageSize = false;
                        runOnUiThread(() -> Toast.makeText(context, adPostImageModel.getImg_message(), Toast.LENGTH_SHORT).show());
                    } else {
                        checkImageSize = true;
                    }
                    if (checkImageSize && checkDimensions) {
                        File finalFile1 = adforest_rotateImage(imaagesLis.get(i));
    //                    File finalFile1 =new File(imaagesLis.get(i));

                        Uri tempUri = SettingsMain.decodeFile(context, finalFile1);

                        parts.add(adforestst_prepareFilePart("file" + i, tempUri));
                        adforest_uploadImages(parts);

                    }
                }
                return parts;
            }

//从库中选择要发布的图像并将其发送到服务器
@凌驾
ActivityResult上的公共void（int请求代码、int结果代码、意图数据）{
//super.onActivityResult（请求代码、结果代码、数据）；
开关（请求代码）{
案例文件PickerConst.REQUEST\u代码\u照片：
if（resultCode==Activity.RESULT\u OK&&data！=null）{
imagepath=newarraylist（）；
imageRequestCount=1；
addAll（data.getStringArrayListExtra（FilePickerConst.KEY\u SELECTED\u MEDIA））；
if（设置主连接到Internet（上下文））{
如果（ImagePath.size（）>0）{
btnSelectPix.setEnabled（false）；
AsyncImageTask AsyncImageTask=新建AsyncImageTask（）；
asyncImageTask.execute（图像路径）；
}
}
}否则{
btnSelectPix.setEnabled（true）；
Toast.makeText（context，settingsMain.getAlertDialogMessage（“internetMessage”），Toast.LENGTH_SHORT.show（）；
}
打破
}
}
私有void adforest_上传图像（列出部分）{
Log.d（“info image parts”，parts.toString（））；
字符串ad_id=Integer.toString（addId）；
请求体adID=
RequestBody.create(
okhttp3.MultipartBody.FORM，ad_id）；
Log.d（“info SendImage”，addId+）；
final Call req=restService.postploadImage（adID，parts，UrlController.UploadImageAddHeaders（context））；
请求排队（新回调（）{
@凌驾
公共void onResponse（调用、响应）{
if（response.issusccessful（））{
Log.v（“信息上传”，response.toString（））；
JSONObject responseobj=null；
试一试{
responseobj=newjsonobject（response.body（）.string（））；
Log.d（“info UploadImage对象”，“”+responseobj.getJSONObject（“数据”）.toString（））；
if（responseobj.getBoolean（“成功”））{
adforest_updateImages（responseobj.getJSONObject（“数据”）；
int selectedImageSize=ImagePath.size（）；
int totalSize=currentSize+selectedImageSize；
Log.d（“info image2”、“muImage”+总大小+“IMAGEPATH”+总上传图像）；
如果（totalSize==totalUploadedImages）{
adforest_上传成功图像（）；
imagepath.clear（）；
清除路径（）；
如果（allFile.size（）>0）{
for（文件：allFile）{
if（file.exists（））{
if（file.delete（））{
Log.d（“文件已删除：”，file.getPath（））；
}否则{
Log.d（“文件未删除：”，file.getPath（））；
}
}
}
}
}
}否则{
adforest_UploadFailedImage（）；
Toast.makeText（context，responseobj.get（“message”）.toString（），Toast.LENGTH\u SHORT.show（）；
}
}捕获（JSONException e）{
adforest_UploadFailedImage（）；
e、 printStackTrace（）；
}捕获（IOE异常）{
adforest_UploadFailedImage（）；
e、 printStackTrace（）；
}
btnSelectPix.setEnabled（true）；
}否则{
adforest_UploadFailedImage（）；
}
}
@凌驾
失败时公共无效（调用调用，可丢弃的t）{
Log.e（“信息上传图像错误：，t.toString（））；
if（TimeoutException的t instanceof）{
adforest_UploadFailedImage（）；
//adforest_requestForImages（）；
}
if（SocketTimeoutException的t实例）{
adforest_UploadFailedImage（）；
//adforest_requestForImages（）；
//
}否则{
adforest_UploadFailedImage（）；
//adforest_requestForImages（）；
}
}
});
}
私有void adforest_UploadFailedImage（）{
进度条设置可见性（视图已消失）；
loadingLayout.setVisibility（View.GONE）；
Gallary.setVisibility（视图.可见）；
Gallary.SetCompoundDrawableswithintrisicBounds（R.drawable.ic\u check\u circle\u black\u 24dp，0,0,0）；
Gallary.se
public static Bitmap scaleDown(Bitmap your_image, float YOUR_SIZE,boolean filter) { //filter false = Pixelated, true = Smooth

        float ratio = Math.min( YOUR_SIZE/ your_image.getWidth(),
                YOUR_SIZE/ your_image.getHeight());
        int width = Math.round( ratio * your_image.getWidth());
        int height = Math.round( ratio * your_image.getHeight());

        Bitmap newBitmap = Bitmap.createScaledBitmap(your_image, width, height,
                filter);
        return newBitmap;
    }

inImage.compress(Bitmap.CompressFormat.JPEG, 100, bytes);