messagemanager.java

The Funambol J2ME Mail Client aims to be a light, easy to use, free email client for J2ME devices.

                );
        mailsrc.setListener(listener);
        
        Log.info("Source: "+mailsrc.getConfig().getName());
        Log.info("SyncMode: "+mailsrc.getConfig().getSyncMode());
        
        try {
            setFilter(mailsrc, ConfigManager.getConfig().getMailFilter());
            // FIXME!
            if (mode != -1) {
                client.sync(mailsrc, mode);
            } else {
                client.sync(mailsrc);
            }
            
        } finally {
            client.dispose();
        }
        
        long syncTime = System.currentTimeMillis() - start;
        Log.info("######## Sync Time: " + (syncTime/1000));
        
        Log.info("- End Sync -");
        
    }
    
    public Message getFullMessage(String folder, String messageId)
    throws ConfigException, MailException, SyncException {
        Log.info("MessageManager: retrieving the full content of " + messageId);
        Message msg = retrieveMessage(folder, messageId, false);
        return msg;
    }
    
    /**
     * Delete a message from a folder
     * @param msg the message to be deleted
     */
    public void deleteMessage(Message msg) throws ConfigException, MailException {
        if ((ConfigManager.getConfig().isEnableDeletePropagation())) {
            updateMessageFlag(msg, MessageFlags.DELETED, true);
        }
        msg.getParent().deleteMessage(msg);
        
    }
    
    
    /**
     * remove a folder and recreate it empty
     * @param  folder the folder to be removed (as one of <ul>
     * <li>MessageManager.INBOX</li>
     * <li>MessageManager.OUTOX</li>
     * <li>MessageManager.DRAFTS</li>
     * <li>MessageManager.SENT</li></ul>
     * @throws MailException if we have problem recreating the folder
     */
    public void emptyFolder(int folderId) throws MailException {
        
        
        String folderName = "";
        switch (folderId) {
            case INBOX:
                folderName = Store.INBOX;
                break;
            case OUTBOX:
                folderName = Store.OUTBOX;
                break;
            case DRAFTS:
                folderName = Store.DRAFTS;
                break;
            case SENT:
                folderName = Store.SENT;
                break;
        }
        if (!"".equals(folderName)) {
            msgStore.removeFolder(folderName);
            msgStore.createFolder(folderName);
        }
    }
    
    /**
     * Sets Message Flags after a messages one or more of its property flag
     * @param msg the message to be flagged
     * @param flag is the flag to be added to the message <code>msg</code>
     */
    public void updateMessageFlag(Message msg, int flag, boolean value)
    throws MailException {
        
        // The flag is already set, nothing to change.
        boolean current = msg.getFlags().isSet(flag);
        if(current == value) {
            Log.debug("Flag: "+flag+" already set");
            return;
        }
        
        //Creates MessageFlags to put into updated items HashTable
        MessageFlags flags = new MessageFlags(msg.getFlags());
        flags.setFlag(flag, value);
        
        // OPENED or FLAGGED flags must be set into the current
        // msg and saved immediately, the others will be set after the sync.
        switch (flag) {
            case MessageFlags.DELETED:
                updateMessageFlags(msg, flags);
                break;
            case MessageFlags.ANSWERED:
            case MessageFlags.DRAFT:
            case MessageFlags.FORWARDED:
            case MessageFlags.PARTIAL:
                //Call update for SyncML
                updateMessageFlags(msg, flags);
                break;
            case MessageFlags.OPENED:
            case MessageFlags.FLAGGED:
                //Call update for SyncML
                updateMessageFlags(msg, flags);
                //Save the updated flags message into the folder
                msg.getFlags().setFlag(flag, value);
                Folder msgFolder = msg.getParent();
                msgFolder.appendMessage(msg);
                break;
            default:
                break;
                
        }
    }
    
    /**
     * Receive messages from the server.
     */
    public void receive() throws SyncException, ConfigException {
        this.sync(SyncML.ALERT_CODE_ONE_WAY_FROM_SERVER);
    }
    
    /**
     * Set a filter on the underlying MailSyncSource. This method
     * must be called on an open connection only.
     * The filter is lost after a close() call.
     *
     *
     * @param MailFilter the filter to apply, or null to remove it
     * @throws MailClientException if the connection is not open
     */
    private void setFilter(MailSyncSource ss, MailFilter filter) throws SyncException {
        
        // Nullify the filter if the source is present, ignore otherwise
        if (filter == null) {
            if(ss != null) {
                ss.setFilter(null);
            }
            return;
        }
        
        // Throw an exception if the source is not initialized yet
        if(ss == null) {
            Log.error(this, "Can't set a filter on a closed connection.");
            throw new SyncException(
                    SyncException.CLIENT_ERROR,
                    "Must be connected to set a filter");
        }
        
        // Set the source filter
        MailSyncFilter sf = new MailSyncFilter(filter);
        ss.setFilter(sf);
    }
    
    
    /**
     * Receive a single message from the server.
     */
    public Message retrieveMessage(String folder,
            String id,
            boolean withAttachments)
            throws SyncException, ConfigException {
        
        Account a = ConfigManager.getConfig().getMailAccount();
        SyncClient client = SyncClient.getSyncClient(a);
        
        try {
            String msgId = folder+"/"+id;
            MailSyncFilter inclusive = new MailSyncFilter(msgId);
            inclusive.enableAttachmentsDownload(withAttachments);
            
            MessageSyncSource msgsrc =
                    new MessageSyncSource(
                    client.loadSourceConfig(
                    SourceConfig.MAIL,
                    SourceConfig.EMAIL_OBJECT_TYPE,
                    "mail"),
                    inclusive);
            
            client.sync(msgsrc, SyncML.ALERT_CODE_ONE_WAY_FROM_SERVER);
            //client.saveSourceConfig();
            
            return msgsrc.getMessage();
            
        } finally {
            client.dispose();
        }
    }
    
    /**
     * Update message flags Lists to be read by MailSyncSource
     *
     *@param msg the the message to be put in the queue
     *@param mf the flags to be set
     */
    public void updateMessageFlags(Message msg, MessageFlags mf) {
        if(msg.getParent().getName().equals(Store.INBOX)) {
            FlagQueue.put(msg.getParent().getName() +"/"+ msg.getMessageId(), mf);
            
        }
    }
    
    
    /**
     * Update message flags Lists to be read by MailSyncSource
     *@param msg the messageInfo of the message to be put in the queue
     *@param mf the flags to be set
     */
    public void updateMessageFlags(MessageInfo msg, MessageFlags mf) {
        if(msg.parent.getName().equals(Store.INBOX)) {
            FlagQueue.put(msg.parent.getName() +"/"+ msg.messageId, mf);
            
        }
    }
    
    
    //--------------------------------------------------------- Private Methods
}