Bildgröße ändern, bevor sie an den Firebase gesendet wird

Question

Ich habe diesen Code unten, ich möchte die Bildqualität von der Kamera oder Galerie vor dem Senden an Firebase reduzieren. Der Pfad (Uri) des Bildes wird gesendet, wie kann ich hier einen Code implementieren?

Wie kann ich es tun? ................................................. .................................................. .....................................

private void showFileChooser() { 
    Intent intent = new Intent(); 
    intent.setType("image/*"); 
    intent.setAction(Intent.ACTION_GET_CONTENT); 
    startActivityForResult(Intent.createChooser(intent, "Select Picture"), PICK_IMAGE_REQUEST); 
} 

@Override 
protected void onActivityResult(int requestCode, int resultCode, Intent data) { 
    super.onActivityResult(requestCode, resultCode, data); 
    if ((requestCode == PICK_IMAGE_REQUEST || requestCode == REQUEST_IMAGE_CAPTURE) && resultCode == RESULT_OK && data != null && data.getData() != null) { 
     filePath = data.getData(); 
     if (requestCode == PICK_IMAGE_REQUEST) { 

      try { 
       Bitmap bitmap = MediaStore.Images.Media.getBitmap(getContentResolver(), filePath); 
       imageView.setImageBitmap(bitmap); 
      } catch (IOException e) { 
       e.printStackTrace(); 
      } 
     } else if (requestCode == REQUEST_IMAGE_CAPTURE) { 
      filePath = data.getData(); 
      Uri selectedImageUri = data.getData(); 
      imageView.setImageURI(selectedImageUri); 

     } 
    } 
} 




public String getFileExtension(Uri uri) { 
    ContentResolver cR = getContentResolver(); 
    MimeTypeMap mime = MimeTypeMap.getSingleton(); 
    return mime.getExtensionFromMimeType(cR.getType(uri)); 
} 

private void uploadFile() { 
    //checking if file is available 
    if (filePath != null && (editTextName.getText().toString().length() > 0) 
       && (editTextName1.getText().toString().length() > 0) 
       && (editTextName2.getText().toString().length() > 0) 
       ) { 


      //displaying progress dialog while image is uploading 
      final ProgressDialog progressDialog = new ProgressDialog(this); 
      progressDialog.setTitle("Uploading"); 
      progressDialog.show(); 

      //getting the storage reference 
      StorageReference sRef = storageReference.child(Constants.STORAGE_PATH_UPLOADS + System.currentTimeMillis() + "." + getFileExtension(filePath)); 

     //adding the file to reference 
     sRef.putFile(filePath) 
       .addOnSuccessListener(new OnSuccessListener<UploadTask.TaskSnapshot>() { 
        @Override 
        public void onSuccess(UploadTask.TaskSnapshot taskSnapshot) { 
         //dismissing the progress dialog 
         progressDialog.dismiss(); 

         //displaying success toast 
         Toast.makeText(getApplicationContext(), "File Uploaded ", Toast.LENGTH_LONG).show(); 
         Intent intent = new Intent(MainActivity.this, ShowMap.class); 
         startActivity(intent); 

         //creating the upload object to store uploaded image details 
         Upload upload = new Upload(editTextName.getText().toString().trim(), editTextName1.getText().toString().trim(), editTextName2.getText().toString().trim(), editTextLatitude.getText().toString().trim(), editTextLongitude.getText().toString().trim(), taskSnapshot.getDownloadUrl().toString()); 

         //adding an upload to firebase database 
         String uploadId = mDatabase.push().getKey(); 
         mDatabase.child(uploadId).setValue(upload); 



        } 
       }) 
        .addOnFailureListener(new OnFailureListener() { 
         @Override 
         public void onFailure(@NonNull Exception exception) { 
          progressDialog.dismiss(); 
          Toast.makeText(getApplicationContext(), exception.getMessage(), Toast.LENGTH_LONG).show(); 
         } 
        }) 
        .addOnProgressListener(new OnProgressListener<UploadTask.TaskSnapshot>() { 
         @Override 
         public void onProgress(UploadTask.TaskSnapshot taskSnapshot) { 
          //displaying the upload progress 
          double progress = (100.0 * taskSnapshot.getBytesTransferred())/taskSnapshot.getTotalByteCount(); 
          progressDialog.setMessage("Uploaded " + ((int) progress) + "%..."); 
         } 
        }); 
     }else{ 
      Toast.makeText(this, "Error", Toast.LENGTH_LONG).show(); 

    } //display an error if no file is selected 

    } 

Answer 1

Ich war in der Lage zu lösen!

Resize Bild

private String storeImage(Bitmap image) { 
     File pictureFile = getOutputMediaFile(); 
     if (pictureFile == null) { 
      Log.d("log", 
        "Error creating media file, check storage permissions: ");// e.getMessage()); 
      return null; 
     } 
     try { 
      FileOutputStream fos = new FileOutputStream(pictureFile); 
      image.compress(Bitmap.CompressFormat.JPEG, 30, fos); 
      fos.close(); 
     } catch (FileNotFoundException e) { 
      Log.d("log", "File not found: " + e.getMessage()); 
     } catch (IOException e) { 
      Log.d("log", "Error accessing file: " + e.getMessage()); 
     } 
     return null; 
    } 

    /** Create a File for saving an image or video */ 
    private File getOutputMediaFile(){ 
     // To be safe, you should check that the SDCard is mounted 
     // using Environment.getExternalStorageState() before doing this. 
     File mediaStorageDir = new File(Environment.getExternalStorageDirectory() 
       + "/Android/data/" 
       + getApplicationContext().getPackageName() 
       + "/Files"); 

     // This location works best if you want the created images to be shared 
     // between applications and persist after your app has been uninstalled. 

     // Create the storage directory if it does not exist 
     if (! mediaStorageDir.exists()){ 
      if (! mediaStorageDir.mkdirs()){ 
       return null; 
      } 
     } 
     // Create a media file name 
     String timeStamp = new SimpleDateFormat("ddMMyyyy_HHmm").format(new Date()); 
     File mediaFile; 
     String mImageName="MI_"+ timeStamp +".jpg"; 
     mediaFile = new File(mediaStorageDir.getPath() + File.separator + mImageName); 
     Log.v("log", "save: " + mediaStorageDir.getAbsoluteFile()); 
     return mediaFile; 
    } 

onActivityResult

protected void onActivityResult(int requestCode, int resultCode, Intent data) { 
    super.onActivityResult(requestCode, resultCode, data); 
    if ((requestCode == PICK_IMAGE_REQUEST || requestCode == REQUEST_IMAGE_CAPTURE) && resultCode == RESULT_OK && data != null && data.getData() != null) { 
     filePath = data.getData(); 
     if (requestCode == PICK_IMAGE_REQUEST) { 
      try { 
       bitmap = MediaStore.Images.Media.getBitmap(getContentResolver(), filePath); 
       storeImage(bitmap); 
       imageView.setImageBitmap(bitmap); 
       Log.v("log", "path = " + getOutputMediaFile().getAbsoluteFile()); 
       imagemfinal = Uri.fromFile(getOutputMediaFile().getAbsoluteFile()); 
      } catch (IOException e) { 
       e.printStackTrace(); 
      } 
     } else if (requestCode == REQUEST_IMAGE_CAPTURE) { 
      filePath = data.getData(); 
      Uri selectedImageUri = data.getData(); 
      try { 
       Bitmap bitmap1 = MediaStore.Images.Media.getBitmap(this.getContentResolver(), selectedImageUri); 
       storeImage(bitmap1); 
       imagemfinal = Uri.fromFile(getOutputMediaFile().getAbsoluteFile()); 
       imageView.setImageBitmap(bitmap1); 
      } catch (IOException e) { 
       e.printStackTrace(); 
      } 
     } 
    } 
} 

Answer 2

Bitmap image2 = (Bitmap) data.getExtras().get("data"); 
img.setImageBitmap(image2); 
String incident_ID = IncidentFormActivity.incident_id; 

imagepath="/sdcard/RDMS/"+incident_ID+ x + ".PNG"; 
File file = new File(imagepath); 
    try { 
     double xFactor = 0; 
     double width = Double.valueOf(image2.getWidth()); 
     Log.v("WIDTH", String.valueOf(width)); 
     double height = Double.valueOf(image2.getHeight()); 
     Log.v("height", String.valueOf(height)); 
     if(width>height){ 
     xFactor = 841/width; 
    } 
    else{ 
     xFactor = 595/width; 
    } 


Log.v("Nheight", String.valueOf(width*xFactor)); 
Log.v("Nweight", String.valueOf(height*xFactor)); 
int Nheight = (int) ((xFactor*height)); 
int NWidth =(int) (xFactor * width) ; 

bm = Bitmap.createScaledBitmap(image2,NWidth, Nheight, true); 
file.createNewFile(); 
FileOutputStream ostream = new FileOutputStream(file); 
bm.compress(CompressFormat.PNG, 100, ostream); 
ostream.close(); 

Dies ist Code für die Größenänderung der Bilder.

Answer 3

Überprüfen Sie diese Klasse. Dies ist hilfreich, Bild finden Sie unter

class ImageFile(val uri: Uri, name: String) { 

    val filename: String 

    init { 
     val file = File(Environment.getExternalStorageDirectory().toString() + "/Documents") 
     if (!file.exists()) { 
      file.mkdirs() 
     } 
     val fileNoMedia = File(file.absolutePath + "/.nomedia") 
     if (!fileNoMedia.exists()) 
      fileNoMedia.createNewFile() 
     if (name.toLowerCase().endsWith(".pdf")) { 
      filename = file.absolutePath + "/" + System.currentTimeMillis() + ".pdf" 
     } else { 
      filename = file.absolutePath + "/" + System.currentTimeMillis() + ".jpg" 
     } 
    } 

    @Throws(IOException::class) 
    fun copyFileStream(context: Context, uri: Uri): String { 
     if (filename.endsWith(".pdf") || filename.endsWith(".PDF")) { 
      var ins: InputStream? = null 
      var os: OutputStream? = null 
      try { 
       ins = context.getContentResolver().openInputStream(uri) 
       os = FileOutputStream(filename) 
       val buffer = ByteArray(1024) 
       var length: Int = ins.read(buffer) 
       while (length > 0) { 
        os.write(buffer, 0, length); 
        length = ins.read(buffer) 
       } 
      } catch (e: Exception) { 
       e.printStackTrace(); 
      } finally { 
       ins?.close() 
       os?.close() 
      } 
     } else { 
      var ins: InputStream? = null 
      var os: OutputStream? = null 
      try { 
       ins = context.getContentResolver().openInputStream(uri) 
       var scaledBitmap: Bitmap? = null 
       val options = BitmapFactory.Options() 
       options.inJustDecodeBounds = true 
       var bmp = BitmapFactory.decodeStream(ins, null, options) 
       var actualHeight = options.outHeight 
       var actualWidth = options.outWidth 

       //  max Height and width values of the compressed image is taken as 816x612 
       val maxHeight = 816.0f 
       val maxWidth = 612.0f 
       var imgRatio = (actualWidth/actualHeight).toFloat() 
       val maxRatio = maxWidth/maxHeight 

       //  width and height values are set maintaining the aspect ratio of the image 
       if (actualHeight > maxHeight || actualWidth > maxWidth) { 
        if (imgRatio < maxRatio) { 
         imgRatio = maxHeight/actualHeight 
         actualWidth = (imgRatio * actualWidth).toInt() 
         actualHeight = maxHeight.toInt() 
        } else if (imgRatio > maxRatio) { 
         imgRatio = maxWidth/actualWidth 
         actualHeight = (imgRatio * actualHeight).toInt() 
         actualWidth = maxWidth.toInt() 
        } else { 
         actualHeight = maxHeight.toInt() 
         actualWidth = maxWidth.toInt() 

        } 
       } 

       //  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 = ByteArray(16 * 1024) 


       try { 
        //   load the bitmap from its path 
        ins.close() 
        ins = context.getContentResolver().openInputStream(uri) 
        bmp = BitmapFactory.decodeStream(ins, null, options) 
       } catch (exception: OutOfMemoryError) { 
        exception.printStackTrace() 

       } 

       try { 
        scaledBitmap = Bitmap.createBitmap(actualWidth, actualHeight, Bitmap.Config.ARGB_8888) 
       } catch (exception: OutOfMemoryError) { 
        exception.printStackTrace() 
       } 

       val ratioX = actualWidth/options.outWidth.toFloat() 
       val ratioY = actualHeight/options.outHeight.toFloat() 
       val middleX = actualWidth/2.0f 
       val middleY = actualHeight/2.0f 

       val scaleMatrix = Matrix() 
       scaleMatrix.setScale(ratioX, ratioY, middleX, middleY) 

       val canvas = Canvas(scaledBitmap!!) 
       canvas.matrix = scaleMatrix 
       canvas.drawBitmap(bmp, middleX - bmp.width/2, middleY - bmp.height/2, Paint(Paint.FILTER_BITMAP_FLAG)) 

       os = FileOutputStream(filename) 
       scaledBitmap.compress(Bitmap.CompressFormat.JPEG, 80, os) 
       val buffer = ByteArray(1024) 
       var length: Int = ins.read(buffer) 
       while (length > 0) { 
        os.write(buffer, 0, length); 
        length = ins.read(buffer) 
       } 
      } catch (e: Exception) { 
       e.printStackTrace(); 
      } finally { 
       ins?.close() 
       os?.close() 
      } 
     } 
     return filename 
    } 

    fun calculateInSampleSize(options: BitmapFactory.Options, reqWidth: Int, reqHeight: Int): Int { 
     val height = options.outHeight 
     val width = options.outWidth 
     var inSampleSize = 1 
     if (height > reqHeight || width > reqWidth) { 
      val heightRatio = Math.round(height.toFloat()/reqHeight.toFloat()) 
      val widthRatio = Math.round(width.toFloat()/reqWidth.toFloat()) 
      inSampleSize = if (heightRatio < widthRatio) heightRatio else widthRatio 
     } 
     val totalPixels = (width * height).toFloat() 
     val totalReqPixelsCap = (reqWidth * reqHeight * 2).toFloat() 
     while (totalPixels/(inSampleSize * inSampleSize) > totalReqPixelsCap) { 
      inSampleSize++ 
     } 

     return inSampleSize 
    } 
} 

für mehr zu komprimieren this link