We Keep Coding

Android - Error when uploading a bitmap to server C#

When i make upload of a image in Android to the server (C #) it generates an error converting the image to byte Array, this happens with some images which is very strange because this error is not always generated, that is, depending the image is correctly converted or not.
The conversion code:
ByteArrayOutputStream stream = new ByteArrayOutputStream();
bitmapPhoto.compress(Bitmap.CompressFormat.JPEG, 50, stream);
final byte[] img_byte = stream.toByteArray();
final String imageString = Base64.encodeToString(img_byte, Base64.DEFAULT);
When receiving in C# I make the following conversion in the string, generating a byte Array and then for the MemoryStream.
byte[] novaFoto = Convert.FromBase64String(NovaFoto.FotoString);
using (MemoryStream stream = new MemoryStream(novaFoto))
{
Image image = Image.FromStream(stream);
}
depending at the image the error appears in either Convert.FromBase64String or Image.FromStream.
Can anyone help me with this? If you have another method i like this.Thanks!!

Getting the binary form of an image in android studio

I'm trying to get the binary form of an image in android to send to a server, but it's not working. When I printed the bytes being created it returns this : [B#cfc2978
public Byte[] getImageBytes(Bitmap bmp){
ByteArrayOutputStream baos = new ByteArrayOutputStream();
bmp.compress(Bitmap.CompressFormat.JPG, 50, baos);
byte[] imageBytes = baos.toByteArray();
System.out.println(imageBytes);
return imageBytes;
}
Can Anyone help me find out why this is happening and how to fix it? To clarify, i need to send the binary form of the image to the server to be processed. The testing was done through the emulator.

Android base 64 encode string not showing actual image

Hello I am working with android image processing via base 64 encoding and decoding.I need to send an encoded base 64 string to server as a string . When I tried it in android side , I can able to decode it into original image.and my decoding and encoding are as follows
public void base(Bitmap bitmap)
{
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
bitmap.compress(Bitmap.CompressFormat.PNG, 100, byteArrayOutputStream);
byte[] byteArray = byteArrayOutputStream .toByteArray();
String encoded = Base64.encodeToString(byteArray, Base64.DEFAULT);
toimag(encoded);
String a=encoded.replaceAll("\\s+","");
Log.i("strrr",a);
}
public void toimag(String encodedImage)
{
byte[] decodedString = Base64.decode(encodedImage, Base64.DEFAULT);
Bitmap decodedByte = BitmapFactory.decodeByteArray(decodedString, 0, decodedString.length);
logo.setImageBitmap(decodedByte);
}
But I cant able to get the actual image using http://www.askapache.com/online-tools/base64-image-converter/ . It show only a part of my actual image. This is my base 64 string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 can I resolve this issue ? Is there any problem with this encoded string ? Please help. Thanks in advance :)

It appears you are cutting and pasting from the logcat. logcat truncates long messages, so you should not rely on it for copying large pieces of data. You should save the base64 string out to a file and then try your validation using that file.

For Encode image to Base64
ByteArrayOutputStream baos = new ByteArrayOutputStream();
bitmap.compress(Bitmap.CompressFormat.PNG, 100, baos);
byte[] b = baos.toByteArray();
String imageEncode = Base64.encodeToString(b,
Base64.DEFAULT);
For decode image
byte[] decodedByte = Base64.decode(imageEncode, 0);
Bitmap newBitmap = BitmapFactory.decodeByteArray(decodedByte, 0, decodedByte.length);
logo.setImageBitmap(newBitmap);

Converting bitmap to byte array, to string, then all the way back

I have tried several different methods found in the java documentation, as well as several solutions from other SO questions and have successfully gotten a Bitmap to convert to a byte[] and back again.
The problem is that I now need to convert this byte[] to a String, then back to a byte[], then back to a Bitmap again. To recap what I need:
Bitmap -> byte[] -> String -> byte[] -> Bitmap
I know this sounds strange but what I'm trying to accomplish must be done this way. Below is what I have tried, if anyone could point out what I'm doing wrong I'd greatly appreciate it!
Bitmap bitmap = mv.getDrawingCache();
// Convert bitmap to byte[]
ByteArrayOutputStream output = new ByteArrayOutputStream(bitmap.getByteCount());
bitmap.compress(Bitmap.CompressFormat.PNG, 100, output);
byte[] imageBytes = output.toByteArray();
// Convert byte[] to string
// I have also tried using Base64.encodeToString(imageBytes, 0);
String encodedString = new String(imageBytes);
// Convert string to byte[]
byte[] newImageBytes = encodedString.getBytes();
if (imageBytes == newImageBytes) {
Toast.makeText(SignatureActivity.this, "SUCCESS!!", Toast.LENGTH_SHORT).show();
} else { // Sadly, we always get to this point :(
Toast.makeText(SignatureActivity.this, "BOOO", Toast.LENGTH_SHORT).show();
}
// Convert byte[] back to bitmap
bitmap = BitmapFactory.decodeByteArray(newImageBytes, 0, newImageBytes.length);
Again, going Bitmap -> byte[] -> Bitmap was successful, but adding in the conversion to a String and back is causing the final Bitmap to write an image of 0kb.

The problem is not in the conversion, but how you verify the result. using == to compare two arrays only returns true if they are the same array reference. Since you create a new array with byte[] newImageBytes = encodedString.getBytes(); This will always be false.
See this question for reference.
On another note, if you are going to transfer or use the string in some way, it is probably better to use Base64.encodeToString(imageBytes, Base64.NO_WRAP); to get a string, and get it back with Base64.decode(encodedString, Base64.NO_WRAP).
You can also get the byte array without compressing it, with the copyPixelsToBuffer() method (see this question for an example).

How to convert String to Image (Java)

I have an issue about my Application in detail.
- I have a java servlet receive data from mms gateway (MM7 protocol)
I get inputstream (image content , message content ) convert to string
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
//String orgin = new String(byteArrayOutputStream.toByteArray(),"UTF-8");
String orgin = Streams.asString(request.getInputStream(), "ISO-8859-1");
Then I substring orgin for image content and convert to base64 and save to image file
but string that I convert to base64 can not save to image because this error
not a jpeg file
I print out string base64 does not start with /9j that mean not jpg format
please suggest or give an example for me
Best reqard
lieang noob noob
sorry for my english :)

This is at least part of your problem:
String orgin = Streams.asString(request.getInputStream(), "ISO-8859-1");
You shouldn't be converting it into a string to start with. It's binary data, right? So read it from the stream as binary data.
Now it sounds like you basically want to get separate "chunks" of that binary data - but converting the data into a string format to start with is not appropriate, unless that binary data really is encoded text.

I think, this might help: http://www.dailycoding.com/Posts/convert_image_to_base64_string_and_base64_string_to_image.aspx

Encoding of image is very simple.
Encoding Source:
Bitmap bm = BitmapFactory.decodeFile(picturePath);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
bm.compress(Bitmap.CompressFormat.JPEG, 100, baos);
byte[] byteArray = baos.toByteArray();
encodedImage = Base64.encodeToString(byteArray, Base64.DEFAULT);
ImageView imageView = (ImageView) findViewById(R.id.imageView1);
imageView.setImageBitmap(BitmapFactory.decodeFile(picturePath));
Decoding Source:
byte[] decodedString;
decodedString = Base64.decode(picture, Base64.DEFAULT);
imageView1.setImageBitmap( BitmapFactory.decodeByteArray(decodedString, 0, decodedString.length));

Use the below code the for the String to Image
here "origin" is a String
import org.apache.commons.codec.binary.Base64;
byte[] imgByteArray = Base64.decodeBase64(origin);
FileOutputStream imgOutFile = new FileOutputStream("C:\\Workspaces\\String_To_Image.jpg");
imgOutFile.write(imgByteArray);
imgOutFile.close();