boxlist.java

手机邮箱撒的方式方式方式的

//#condition MUJMAIL_USR_FOLDERS
/*
MujMail - Simple mail client for J2ME
Copyright (C) 2003 Petr Spatka <[e-mail]>
Copyright (C) 2005 Pavel Machek <[e-mail]>
Copyright (C) 2006 Nguyen Son Tung <[e-mail]>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

package mujmail.mailboxes;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;
import javax.microedition.lcdui.AlertType;
import javax.microedition.lcdui.Choice;
import javax.microedition.lcdui.ChoiceGroup;
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Form;
import javax.microedition.lcdui.Item;
import javax.microedition.lcdui.StringItem;
import javax.microedition.lcdui.TextField;
import javax.microedition.rms.RecordEnumeration;
import javax.microedition.rms.RecordStore;

import mujmail.util.Functions;
import mujmail.InBox;
import mujmail.Lang;
import mujmail.MailDB;
import mujmail.Menu;
import mujmail.MujMail;
import mujmail.MyAlert;
import mujmail.MyException;
import mujmail.PersistentBox;
import mujmail.account.MailAccount;
import mujmail.account.MailAccountDerived;
import mujmail.ordering.comparator.MailBoxNameComparator;

/**
 * Manages user folders. Holds list of this folders. 
 * Take care about basic folder operation like creating, loading, removing.
 */
public class BoxList {
    /** Flag signals if we want to print debug prints */
    private static final boolean DEBUG = false;
    
    private static final String dbName         = "_MailBoxesList"; /// Name of database with folders
    private static final String dbUserFolder   = "UserFolder_";    /// Prefix used for databases with user folders
    private int maxDBFieldSize = 128;                              /// Maximum size of one record store entry ... now 2*32 Unicode characters
    
    private MujMail mujMail; /// mujMail instance
    private Vector/*<InBox>*/ mailBoxes; /// list of mailBoxes stored this BoxList
    
    /**
     * Creates new holder for user folders
     * 
     * @param mujMail running mujmail instance
     */
    public BoxList( MujMail mujMail) {
        this.mujMail = mujMail;
        mailBoxes = new Vector(5);
    }
    
    /** 
     * Loads mail stored in persistent storage into mail boxes.
     * Also loads mail into standard mujmail folders (like InBox, Drafts, etc)
     * <p>
     * Note: Call only once, another call will add user folders again.
     */
    public void loadBoxes() {
        Thread lt = new Thread() {
            public void run() {
                loadingBoxesThread();
            }
        };
        lt.start();
    }
    
    /** Real worker for methoed {@link #loadBoxes} */
    private void loadingBoxesThread() {
        // Open box db
        try {
            if (DEBUG) { System.out.print("DEBUG BoxList.loadingBoxesThread .. Loading mailboxes\n"); }
            mujMail.loadDefaulFolders();
            if (DEBUG) { System.out.print("DEBUG BoxList.loadingBoxesThread .. DefaultMailBoxes loaded\n"); }
            RecordStore rs = Functions.openRecordStore(dbName, true);
            if (DEBUG) {
                    System.out.println("Record store: " + rs.getName());
                    System.out.println("    Number of rec  = " + rs.getNumRecords());
                    System.out.println("    Total size     = " + rs.getSize());
                    System.out.println("    Version        = " + rs.getVersion());
                    System.out.println("    Last modified  = " + rs.getLastModified());
                    System.out.println("    Size available = " + rs.getSizeAvailable());
                System.out.print("\n");
            }

            if (rs.getNextRecordID() == 1) {
                return;
            }
            RecordEnumeration re = rs.enumerateRecords(null, null, false);
            byte[] data = new byte[maxDBFieldSize];
            ByteArrayInputStream buffer = new ByteArrayInputStream(data);            
            DataInputStream stream = new DataInputStream(buffer);
            
            while (re.hasNextElement()) {
                int id = re.nextRecordId();
                // Ensure if buffer is big enought to hold all data
                int entrySize = rs.getRecordSize(id);
                if (entrySize > maxDBFieldSize) {
                    // Note: if maxDBFieldSize set correctly should not happned
                    data = new byte[entrySize + 32];
                    maxDBFieldSize = entrySize + 32;
                    buffer = new ByteArrayInputStream(data);
                    stream = new DataInputStream(buffer);
                }
                rs.getRecord( id, data, 0); // Element from record strore
                stream.reset();
                
                String folderName = stream.readUTF();
                String dbName     = stream.readUTF();
                
                InBox boxElement = new InBox(dbName, folderName);
                boxElement.setUserBoxListDBRecID(id);
                if (DEBUG) { System.out.println("BoxList.loadBoxes ... adding user box \"" + folderName + "\" with database \"" + dbName + "\""); }
                // TODO make it in some serial and not parallel way as now ... notify if mailbox is loaded
                mailBoxes.addElement(boxElement);
                MailDB  boxElementDB = boxElement.getMailDB();
                boxElementDB.loadDB(boxElement);
                synchronized (boxElementDB) {
                    boxElementDB.waitForTaskEnd();
                }
            }
            sort();
            if (DEBUG) System.out.println("Loading mailboxes ... done\n");
            System.gc();
            
        } catch (Exception ex) {
            // TODO: ma byt druhy obekt null?
            mujMail.alert.setAlert(this, null, Lang.get(Lang.ALRT_MB_CREATING) + Lang.get(Lang.FAILED) + ": " + ex, MyAlert.DEFAULT, AlertType.ERROR);
        }
    }
    
    /** 
     * Create new user folder. Shows setting form to customize mail box settings.
     * <p>Create persistentBox and add them into user folder box list. 
     */
    public synchronized void createPersistentBox() {
        // Generate new name for DB file
        int max = 0; // Maximum index used in folderName;
        String[] folders = RecordStore.listRecordStores();
        for(int i = 0; i < folders.length; i++) {
            if (folders[i].startsWith(dbUserFolder)) {
                // Parse numeric suffix
                int j = dbUserFolder.length();
                int jMax = folders[i].length();
                int val = 0;

                while (j < jMax) {
                    char c = folders[i].charAt(j);
                    if (!Character.isDigit(c)) break;
                    val = val * 10 + Character.digit(c,10);
                    j++;
                }
                
                if (val > max) {
                    max = val;
                }
            }
        }
        
        // Step 2 - find maximum in mailBox vector 
        //  (cover case if some mailbox hasn't created dbfiles yet)
        for(int i = 0; i < mailBoxes.size(); i++) {
            String DBFileName = ((PersistentBox)mailBoxes.elementAt(i)).getDBFileName();
            if (DBFileName.startsWith(dbUserFolder)) {
                // Parse numeric suffix
                int j = dbUserFolder.length();
                int jMax = DBFileName.length();
                int val = 0;

                while (j < jMax) {
                    char c = DBFileName.charAt(j);
                    if (!Character.isDigit(c)) break;
                    val = val * 10 + Character.digit(c,10);
                    j++;
                }
                
                if (val > max) {
                    max = val;
                }
            }
        }

        max++; // Now is max new empty suffix
        
        // Add entry into database
        String newBoxFolderName = "UserFolder " + Integer.toString(max);
        String newBoxDBName = dbUserFolder + Integer.toString(max);
        int recordID = -1;
        try {
            recordID = changeStoredUserBoxInfo( -1, newBoxFolderName, newBoxDBName);
        } catch (Exception ex) {
            mujMail.alert.setAlert(this, null, Lang.get(Lang.ALRT_SAVING) + Lang.get(Lang.FAILED) + ": " + ex, MyAlert.DEFAULT, AlertType.ERROR);
        }
        InBox newBox = new InBox(newBoxDBName, newBoxFolderName);
        newBox.setUserBoxListDBRecID(recordID);
        mailBoxes.addElement(newBox);
        sort();
        newBox.getMailDB().loadDB(newBox);
        // refresh is done in sorting
        // mujMail.getMenu().refresh(Menu.FOLDERS, false); 
        editUserMailBoxSettings( mailBoxes.indexOf(newBox));
    }
    
    /**
     * Sorts user mail boxes by name
     */
    public void sort() {
        Functions.sort(mailBoxes, new MailBoxNameComparator());
        mujMail.getMenu().refresh(Menu.FOLDERS, false);
    }
    
    /** 
     * Gets vector of user created PersistentBoxes
     * @return Vector where user mailboxes are stored
     */
    public final Vector getBoxList() {
        return mailBoxes;
    }
    
    /** 
     * Calculate space that holds user folders databases
     * @return User folders occupied db space
     */
    public synchronized int spaceOccupied() {
        int space = 0;
        for( int i = 0; i < mailBoxes.size(); i++) {
            space += ((PersistentBox)mailBoxes.elementAt(i)).getOccupiedSpace();
        }
        return space;
    }

    /**
     * Remove mails from all user boxes.
     * <p>
     * Is intended for clearing databases and creating space for new mails.
     */ 
    public synchronized void deleteAllMailsFromAllUserBoxesAndDB() {
        boolean exception = false;

        for( int i = 0; i < mailBoxes.size(); i++) {