photoalbum.java

J2ME PHOTO处理

     */
    private void setupImageList() {
        imageNames = new Vector();
        imageList = new List("Images", List.IMPLICIT);
        imageList.addCommand(exitCommand);
        imageList.addCommand(aboutCommand);
        imageList.setCommandListener(this);

        for (int n = 1; n < 100; n++) {
            String nthImage = "PhotoImage-" + n;
            String image = getAppProperty(nthImage);

            if ((image == null) || (image.length() == 0)) {
                break;
            }

            String nthTitle = "PhotoTitle-" + n;
            String title = getAppProperty(nthTitle);

            if ((title == null) || (title.length() == 0)) {
                title = image;
            }

            imageNames.addElement(image);
            imageList.append(title, null);
        }

        imageNames.addElement("testchart:");
        imageList.append("Test Chart", null);
    }

    /**
     * The Run method is used to load the images.
     * A form is used to report the progress of loading images
     * and when the loading is complete they are displayed.
     * Any errors that occur are reported using an Alert.
     * Images previously loaded into the PhotoFrame are discarded
     * before loading.
     * <P>
     * Load images from resource files using <code>Image.createImage</code>.
     * Images may be in resource files or accessed using http:
     * The first image is loaded to determine whether it is a
     * single image or a sequence of images and to make sure it exists.
     * If the name given is the complete name of the image then
     * it is a singleton.
     * Otherwise it is assumed to be a sequence of images
     * with the name as a prefix.  Sequence numbers (n) are
     * 0, 1, 2, 3, ....  The full resource name is the concatenation
     * of name + n + ".png".
     * <p>
     * If an OutOfMemoryError occurs the sequence of images is truncated
     * and an alert is used to inform the user. The images loaded are
     * displayed.
     * @see createImage
     */
    public void run() {
        Thread mythread = Thread.currentThread();
        Vector images = new Vector(5);
        /* Free images and resources used by current frame. */
        frame.reset();

        try { // Catch OutOfMemory Errors

            try {
                if (imageName.startsWith("testchart:")) {
                    TestChart t = new TestChart(frame.getWidth(), frame.getHeight());
                    images = t.generateImages();
                } else {
                    // Try the name supplied for the single image case.
                    images.addElement(createImage(imageName));
                }
            } catch (IOException ex) {
                try {
                    int namelen = imageName.length();
                    StringBuffer buf = new StringBuffer(namelen + 8);
                    buf.append(imageName);

                    Runtime rt = Runtime.getRuntime();

                    // Try for a sequence of images.
                    for (int i = 0;; i++) {
                        progressGauge.setValue(i % 10);

                        // If cancelled, discard images and return immediately
                        if (thread != mythread) {
                            break;
                        }

                        // locate the next in the series of images.
                        buf.setLength(namelen);
                        buf.append(i);
                        buf.append(".png");

                        String name = buf.toString();
                        images.addElement(createImage(name));
                    }
                } catch (IOException io_ex) {
                }
            } catch (SecurityException se_ex) {
                // no-retry, just put up the alert
            }

            // If cancelled, discard images and return immediately
            if (thread != mythread) {
                return;
            }

            // If any images, setup the images and display them.
            if (images.size() > 0) {
                frame.setImages(images);
                display.setCurrent(frame);
            } else {
                // Put up an alert saying image cannot be loaded
                alert.setString("Images could not be loaded.");
                display.setCurrent(alert, imageList);
            }
        } catch (OutOfMemoryError err) {
            int size = images.size();

            if (size > 0) {
                images.setSize(size - 1);
            }

            // If cancelled, discard images and return immediately
            if (thread != mythread) {
                return;
            }

            alert.setString("Not enough memory for all images.");

            // If no images are loaded, Alert and return to the list
            // Otherwise, Alert and display the ones that were loaded.
            if (images.size() <= 0) {
                display.setCurrent(alert, imageList);
            } else {
                frame.setImages(images);
                display.setCurrent(alert, frame);
            }
        }
    }

    /**
     * Fetch the image.  If the name begins with "http:"
     * fetch it with connector.open and http.
     * If it starts with "/" then load it from the
     * resource file.
     * @param name of the image to load
     * @return image created
     * @exception IOException if errors occur during image loading
     */
    private Image createImage(String name) throws IOException {
        if (name.startsWith("/")) {
            // Load as a resource with Image.createImage
            return Image.createImage(name);
        } else if (name.startsWith("http:")) {
            // Load from a ContentConnection
            HttpConnection c = null;
            DataInputStream is = null;

            try {
                c = (HttpConnection)Connector.open(name);

                int status = c.getResponseCode();

                if (status != 200) {
                    throw new IOException("HTTP Response Code = " + status);
                }

                int len = (int)c.getLength();
                String type = c.getType();

                if (!type.equals("image/png") && !type.equals("image/jpeg")) {
                    throw new IOException("Expecting image, received " + type);
                }

                if (len > 0) {
                    is = c.openDataInputStream();

                    byte[] data = new byte[len];
                    is.readFully(data);

                    return Image.createImage(data, 0, len);
                } else {
                    throw new IOException("Content length is missing");
                }
            } finally {
                if (is != null) {
                    is.close();
                }

                if (c != null) {
                    c.close();
                }
            }
        } else {
            throw new IOException("Unsupported media");
        }
    }

    /**
     * Open the store that holds the saved options.
     * If an error occurs, put up an Alert.
     */
    void openOptions() {
        try {
            optionsStore = RecordStore.openRecordStore(optionsName, true);
        } catch (RecordStoreException ex) {
            alert.setString("Could not access options storage");
            display.setCurrent(alert);
            optionsStore = null;
        }
    }

    /**
     * Save the options to persistent storage.
     * The options are retrieved ChoiceGroups and stored
     * in Record 1 of the store which is reserved for it.
     * The two options are stored in bytes 0 and 1 of the record.
     */
    void saveOptions() {
        if (optionsStore != null) {
            byte[] options = new byte[2];
            options[0] = (byte)frame.getStyle();
            options[1] = (byte)frame.getSpeed();

            try {
                optionsStore.setRecord(1, options, 0, options.length);
            } catch (InvalidRecordIDException ridex) {
                // Record 1 did not exist, create a new record (Should be 1)
                try {
                    int rec = optionsStore.addRecord(options, 0, options.length);
                } catch (RecordStoreException ex) {
                    alert.setString("Could not add options record");
                    display.setCurrent(alert);
                }
            } catch (RecordStoreException ex) {
                alert.setString("Could not save options");
                display.setCurrent(alert);
            }
        }
    }

    /**
     * Restore the options from persistent storage.
     * The options are read from record 1 and set in
     * the frame and if the optionsForm has been created
     * in the respective ChoiceGroups.
     */
    void restoreOptions() {
        if (optionsStore != null) {
            try {
                byte[] options = optionsStore.getRecord(1);

                if (options.length == 2) {
                    frame.setStyle(options[0]);
                    frame.setSpeed(options[1]);

                    if (optionsForm != null) {
                        borderChoice.setSelectedIndex(options[0], true);
                        speedChoice.setSelectedIndex(options[1], true);
                    }

                    return; // Return all set
                }
            } catch (RecordStoreException ex) {
                // Ignore, use normal defaults
            }
        }
    }

    /**
     * Close the options store.
     */
    void closeOptions() {
        if (optionsStore != null) {
            try {
                optionsStore.closeRecordStore();
                optionsStore = null;
            } catch (RecordStoreException ex) {
                alert.setString("Could not close options storage");
                display.setCurrent(alert);
            }
        }
    }
}