Categories: Java ME | MIDP 2.0 | Code Examples | WMA 2.0 (JSR-205) | S60 3rd Edition, Feature Pack 1

This page was last modified 07:21, 27 May 2008.

From Forum Nokia Wiki

Knowledge Base Home

Overview

This code snippet demonstrates how to convert a resource into a byte array. The snippet assumes that the resource is included in the JAR file, which is used to distribute the application.

Example: To include a file to the JAR package in NetBeans 6.1, do as follows:

1. In the Projects window (select Window > Projects if it's not visible), open the project node for the project to which you want to add the file.
2. Right-click on the Resources node under the project and choose Add Folder. The Add Folder dialog box opens.
3. Select the folder where the resource is (for example, dist/images).
4. Click Open. The folder is added to the project.
5. Clean and build the project (right-click on the project node and select Clean & Build).
6. The resource can be obtained in the code, for example, like this:

InputStream inputStream = getClass().getResourceAsStream("image.jpg");
// ...

Source

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;

/**
 * Constructs a byte array and fills it with data that is read from the
 * specified resource.
 * @param filename the path to the resource
 * @return the specified resource as a byte array
 * @throws java.io.IOException if the resource cannot be read, or the
 *   bytes cannot be written, or the streams cannot be closed
 */
private byte[] obtainByteData(String filename) throws IOException {
    InputStream inputStream = getClass().getResourceAsStream(filename);
    ByteArrayOutputStream outputStream = new ByteArrayOutputStream(1024);
    byte[] bytes = new byte[512];
 
    // Read bytes from the input stream in bytes.length-sized chunks and write
    // them into the output stream
    int readBytes;
    while ((readBytes = inputStream.read(bytes)) > 0) {
        outputStream.write(bytes, 0, readBytes);
    }
 
    // Convert the contents of the output stream into a byte array
    byte[] byteData = outputStream.toByteArray();
    
    // Close the streams
    inputStream.close();
    outputStream.close();
 
    return byteData;
}

The method above can be used, for example, with multipart messages. In the following, a MessagePart object is constructed from a byte array which represents raw data from a JPEG image:

import javax.wireless.messaging.MessagePart;
import javax.wireless.messaging.SizeExceededException;
 
// ...
 
/**
 * Constructs a MessagePart which can be added to a MultipartMessage.
 * @return the constructed MessagePart
 * @throws javax.wireless.messaging.SizeExceededException if the contents
 *   is larger than the available memory or supported size for the message
 *   part
 * @throws java.io.IOException if the byte data cannot be obtained
 */
private MessagePart createMsgPart() throws SizeExceededException,
        IOException {
    String imageContentID = "image01";
    String imageContentLocation = "image.jpg";
    String jpgMIME = "image/jpeg";
    // Convert the image into a byte array and construct a message part using
    // it
    byte[] imageContent = obtainByteData(imageContentLocation);
    MessagePart messagePart = new MessagePart(imageContent, jpgMIME,
            imageContentID, imageContentLocation, null);
    return messagePart;
}

Postconditions

A specified resource is converted into a byte array.

See also

• CS000978 - Sending a multipart MMS