Should I compress a Bitmap before POSTing it to a server? - android

I have a question regarding best practices for this. If I am doing a multi part request to a server, should I compress the .jpg file (assuming the .jpg file is large) I would be POSTing to the API on the client (Android) side?
Or is this usually not a problem since .jpg handles lossy compression already?

Instead of compressing, you may want to resize it instead. Take a look at createScaledBitmap.

Jpg is already a compressed format Compressing a jpg file might even result in a larger file.

Related

Limit max image file size with Picasso

I'm loading images from external URLs with Picasso. To prevent someone from hosting huge files that would hang my app I would like to set a max image file size before downloading it.
Is there a way in Picasso to limit the file size? If no, what's an alternative?
You'll have to provide your own OkHttpClient to Picasso (via its Builder) to handle that. Generally speaking you'll need to issue a request to the server to figure out the size of the image and only then decide if you want to get it or not. Check this answer for more details.

Picasso not loading JPG format

I'm getting some images from api and showing them via picasso library. Unfortunately it isn't showing .JPG formatted images while it perfectly works with jpg images. Is there anyone who had such problem? Is there any cure or we can't use picasso with JPG?
If I remember well, I had the same problem in general with android studio, so this doesn't regard strictly Picasso library. What I know is that in a case (.jpg) those files are recognized as multimedia files (so treated that way) in the opposite case (.JPG) they are considered as files and treated more generally.
Usually I convert all .PNG into .png and all .JPG into .jpg.
Hope it can help you!

Image compression before uploading in android

I have a image uploading module in my app where user can select an image from the gallery. The problem is the size of the image can be upto 10MB. Which is very large, I want to apply some compression technique to these images before uploading them.
I did some research on the internet and found some libraries like ImageMagick, ImgMin which allows easy optimization of the images. Is there any way I can use them in my android project without the involvement of any backend server.
References:
ImgMin
https://github.com/rflynn/imgmin
ImageMagick
http://www.imagemagick.org/script/index.php
An easy option you can try is this method from the Bitmap class.
You can select the compression format of a bitmap and to optimise either the quality, or the file size. A downside is that the you need to get a Bitmap instance to start the compression, which may be something you don't want to do.

How to work around Android Bitmap memory inefficiencies?

We are working on an native Android app that handles large images (5MP+) from the phone's gallery, eventually encoded base 64, JSONized and sent to an upstream server. We've used some of the guidance given in other StackOverflow questions. We've tried hard to keep memory usage to a minimum, following logcat closely, debugging, etc. And while we've gotten under control the "80% use case" we still are getting FATAL errors in certain cases (when the user picks a photo, then cancels, chooses a different one, for instance).
We've found that when importing a 5MP Bitmap, its size quadruples in the Heap (i.e. a 7Mb jpeg becomes 28Mb in memory). We've used tricks to convert to Base64 as efficiently as possible. We've made sure the JSON parser is not leaking and so forth.
So to get back to my original question, is there a way to circumvent Android's Bitmap handling?
eventually encoded base 64, JSONized and sent to an upstream server
Rewrite your Web app to support binary payloads, so that you do not have to do ridiculous stuff like this. Upload JSON-encoded metadata in one request, then upload the image in its original format in a separate request, if need be. Or, use multipart upload to do both in one shot, leaving the image in its original format.
We've found that when importing a 5MP Bitmap, its size quadruples in the Heap (i.e. a 7Mb jpeg becomes 28Mb in memory)
That is because PNGs, JPEGs, and the like are compressed, and the image needs to be uncompressed to be displayed.
is there a way to circumvent Android's Bitmap handling?
You do not say if you are trying to display the image or not. If you are, use BitmapFactory with an appropriate BitmapFactory.Options to scale the image.
If you are not trying to display the image, once you rewrite the Web app to accept a binary payload, you should not need to load the entire image into memory. Just upload it in the format that it already is in, reading in chunks at a time (e.g., 8KB) to write to the OutputStrem of your HTTP PUT (or whatever) for the upload.

Fastest way to read/write a Bitmap from/to file?

I'm currently writing Bitmaps to a png file and also reading them back to a Bitmap. I'm looking for ways to improve the speed at which writing and reading happens. The images need to be lossless since I'm reading them back to edit them.
The place where I see the worst performance is the actual BitmapFactory.decode(...).
Few questions:
1. Is there a faster solution to read/write from file to a Bitmap using NDK?
2. Is there a better library to decode a Bitmap faster?
3. What is the best way to store and read a Bitmap?
Trying to resolve the best/fastest possible way to read/write image to file came down to using plain old BitmapFactory. I have tried using NDK to do the encoding/decoding but that really didn't make a difference.
Essentially the format to use was lossless PNG since I didn't want to loose any quality after editing an image.
The main concept from all this was that I needed to understand was how long encoding took versus decoding. The encoding numbers where in the upper 300-600ms, depending on image size, and decoding was just fast, around 10-23ms.
After understanding all that I just created a worker thread that I passed images needing encoding and let it do the work without affecting the user experience. The image was kept cached in memory just in case it was needed right away before it was completely encoded and saved to file.

Categories

Resources