Android - Save bitmap to SD Card with determinated ProgressDialog

Question

I'm using this AsyncTask for saving my image resource to SD Card:

public class SaveImageAsync extends AsyncTask<String, String, String> {

    private Context mContext;

    int imageResourceID;

    private ProgressDialog mProgressDialog;

    public SaveImageAsync(Context context, int image) 
    {
        mContext = context;
        imageResourceID = image;
    }

    @Override
    protected void onPreExecute() {
        super.onPreExecute();
        mProgressDialog = new ProgressDialog(mContext);
        mProgressDialog.setMessage("Saving Image to SD Card");
        mProgressDialog.setMax(100);
        mProgressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
        mProgressDialog.setIndeterminate(true);
        mProgressDialog.setCancelable(false);
        mProgressDialog.show();
    }

    @SuppressLint("NewApi")
    @Override
    protected String doInBackground(String... filePath) {
        try {


            Bitmap bitmap = BitmapFactory.decodeResource(mContext.getResources(), imageResourceID);

            ByteArrayOutputStream bos = new ByteArrayOutputStream(); 
            bitmap.compress(CompressFormat.JPEG, 100, bos); 
            byte[] bitmapdata = bos.toByteArray();
            ByteArrayInputStream bis = new ByteArrayInputStream(bitmapdata);

            int lenghtOfFile = bitmap.getByteCount();
            Log.d("LOG", "File Lenght = " + lenghtOfFile);

            byte[] buffer = new byte[64];
            int len1 = 0;
            long total = 0;

            while ((len1 = bis.read(buffer)) > 0) {
                total += len1;
                publishProgress("" + (int) ((total * 100) / lenghtOfFile));
                bos.write(buffer, 0, len1);
            }
            bos.flush();
            bos.close();
            bitmap.recycle();
            bis.close();

            return getTempUri().getPath();
        } catch (Exception e) {
            return null;
        }


    }

    protected void onProgressUpdate(String... progress) {
        mProgressDialog.setIndeterminate(false);
        mProgressDialog.setProgress(Integer.parseInt(progress[0]));
    }

    @Override
    protected void onPostExecute(String filename) {
        // dismiss the dialog after the file was saved
        try {
            mProgressDialog.dismiss();
            mProgressDialog = null;
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private Uri getTempUri() {
        return Uri.fromFile(getTempFile());
    }

    private File getTempFile() {
        if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {

            File directory = new File(mContext.getExternalCacheDir().getPath());
            directory.mkdirs();
            File file = new File(directory , "temp.jpg");
            try  {
                file.createNewFile();
            }  catch (IOException e) {}
            return file;
        } else  {
            return null;
        }
    }   
}

And I call it from my Activity with this:

new SaveImageAsync(this, R.drawable.my_image_resource).execute();

It works fine, the problem is that the bitmap size returned by bitmap.getByteCount(); is completely different from the final size of the saved file. The result when the process is completed that the indicated progress is only 20% more or less.

Is there any way to know the final size of the file before save it? Thanks.

Answer 1

Thanks to Baschi answer, bitmapdata.length; is just what I need, this is my AsyncTask for save a bitmap to the SD Card with Determinated ProgressBar, I hope someone will find it useful:

public class SaveImageAsync extends AsyncTask<Void, String, Void> {

    private Context mContext;
    private int imageResourceID;

    private ProgressDialog mProgressDialog;

    public SaveImageAsync(Context context, int image) {
        mContext = context;
        imageResourceID = image;
    }

    @Override
    protected void onPreExecute() {
        super.onPreExecute();
        mProgressDialog = new ProgressDialog(mContext);
        mProgressDialog.setMessage("Saving Image to SD Card");
        mProgressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
        mProgressDialog.setIndeterminate(true);
        mProgressDialog.setCancelable(false);
        mProgressDialog.show();
    }

    @Override
    protected Void doInBackground(Void... filePath) {
        try {
            Bitmap bitmap = BitmapFactory.decodeResource(mContext.getResources(), imageResourceID);

            ByteArrayOutputStream byteOutputStream = new ByteArrayOutputStream(); 
            bitmap.compress(CompressFormat.JPEG, 100, byteOutputStream); 
            byte[] mbitmapdata = byteOutputStream.toByteArray();
            ByteArrayInputStream inputStream = new ByteArrayInputStream(mbitmapdata);

            String baseDir = Environment.getExternalStorageDirectory().getAbsolutePath();
            String fileName = "mySavedImage.jpg";

            OutputStream outputStream = new FileOutputStream(baseDir + File.separator + fileName);
            byteOutputStream.writeTo(outputStream);

            byte[] buffer = new byte[128]; //Use 1024 for better performance
            int lenghtOfFile = mbitmapdata.length;
            int totalWritten = 0;
            int bufferedBytes = 0;

            while ((bufferedBytes = inputStream.read(buffer)) > 0) {
                totalWritten += bufferedBytes;
                publishProgress(Integer.toString((int) ((totalWritten * 100) / lenghtOfFile)));
                outputStream.write(buffer, 0, bufferedBytes);
            }

        } catch (IOException e) { e.printStackTrace(); }
        return null;

    }

    protected void onProgressUpdate(String... progress) {
        mProgressDialog.setIndeterminate(false);
        mProgressDialog.setProgress(Integer.parseInt(progress[0]));
    }

    @Override
    protected void onPostExecute(Void filename) {
        mProgressDialog.dismiss();
        mProgressDialog = null;
    }
}

Use this line in your Activity to save an image:

new SaveImageAsync(this, R.drawable.your_image_resource).execute();

Answer 2

You use PNG compressession and how good this compression works depends on the actual content of the image, i.e. a blank image only containing white space will be of small size, a colorful image where all pixels are different will be of huge size. So long story...the bitmap.getByteCount() gives you the information how much bytes will be used to store the actual image in the memory (uncompressed), not on the SD card (compressed). The difference between your expectation and what you realy get explains the ~20% break point.

If I should guess a solution might be to use the length of the bitmapdata array. I modified your code:

Bitmap bitmap = null;

ByteArrayOutputStream bos = new ByteArrayOutputStream(); 
bitmap.compress(CompressFormat.JPEG, 100, bos); 
byte[] bitmapdata = bos.toByteArray();
ByteArrayInputStream bis = new ByteArrayInputStream(bitmapdata);

int lenghtOfFile = bitmapdata.length;
byte[] buffer = new byte[64];
int currentProcess = 0;
int totalReadedYet = 0;

try {
while ((currentProcess = bis.read(buffer)) > 0) {
    totalReadedYet += currentProcess;
    publishProgress(Integer.toString((int) ((totalReadedYet) / lenghtOfFile)));
    bos.write(buffer, 0, currentProcess);
}

bos.flush();
bos.close();
bitmap.recycle();
bis.close();
} catch (IOException e) {
    e.printStackTrace();
}