synctaskmanager.java

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

        if (toSend == 0 || toSend == MESSAGE_NUMBER_UNKNOWN ) {
            syncEventInfo.setInfoCode(SyncEventInfo.CONNECTION_COMPLETED);
            syncEventInfo.infoMessage =
                    Localization.getMessages().LOADING;
            update(syncEventInfo);
        }
    }
    
    /**
     * Invoked each time data is received from the server, with the timestamp
     * and the size of the received data.
     */
    public void dataReceived(String date, int size) {
        
        // date like Thu, 03 May 2007 14:45:38 GMT
        try{
            if (!ConfigManager.getConfig().getTimeZoneUpdated()) {
                
                Date gmtServerdate = MailDateFormatter.parseRfc2822Date(date);
                Date deviceDate = new Date();
                
                int millisServerDate = (int)gmtServerdate.getTime();
                int millisDeviceDate = (int)deviceDate.getTime();
                int hourServer = (int)(millisServerDate/3600000); //60*60*1000
                int hourDevice = (int)(millisDeviceDate/3600000); //60*60*1000
                int hourDiff = hourDevice - hourServer;
                int minServer = (int)(millisServerDate/60000); //60*60*1000
                int minDevice = (int)(millisDeviceDate/60000); //60*60*1000
                int minDiff = minDevice - minServer - (hourDiff*60);
                StringBuffer offset = new StringBuffer();
                offset.append((hourDiff > 0) ? "+" : "-");
                int mathHourDiff = (Math.abs(hourDiff));
                offset.append((mathHourDiff<=9) ? "0"+mathHourDiff : ""+mathHourDiff);
                int mathMinDiff = (Math.abs(minDiff));
                if(mathMinDiff <= 20 || mathMinDiff >=55)
                    offset.append("00");
                else if(mathMinDiff > 20 || mathMinDiff < 40  )
                    offset.append("30");
                else if (mathMinDiff >=40 || mathMinDiff < 55)
                    offset.append("45");
                
                // Save the new config.
                ConfigManager.getConfig().setTimeZone(offset.toString());
                ConfigManager.saveConfig();
            }
        } catch(ConfigException cex){
            Log.error(this, "dataReceived - " + cex.toString());
            userInfoMessage = Localization.getMessages().CONFIGURATION_ERROR;
        } catch(IOException ioex){
            Log.error(this, "dataReceived - " + ioex.toString());
        }
    }
    
    /**
     * should be called when a userInfoMessage is received
     */
    public void msgReceived(Message msg) {
        this.received++;
        update(msg);
        
        if (toReceive != AccountListener.MESSAGE_NUMBER_UNKNOWN) {
            userInfoMessage = Localization.getMessages().
                    getMESSAGE_X_OF_Y_RECEIVED(received,toReceive);
        } else {
            userInfoMessage = Localization.getMessages().
                    getMESSAGE_X_RECEIVED(received);
        }
        
        syncEventInfo.setInfoCode(SyncEventInfo.MESSAGE_RECEIVED);
        syncEventInfo.infoMessage = userInfoMessage;
        update(syncEventInfo);
    }
    
    /**
     * should be called when a userInfoMessage is sent
     */
    public void msgSent() {
        sent++;
        /*
        if (toSend != AccountListener.MESSAGE_NUMBER_UNKNOWN) {
            userInfoMessage = Localization.getMessages("MessageXofYSent",
                    new Object[]{new Integer(sent), new Integer(this.toSend)});
        } else {
            userInfoMessage = Localization.getMessages("MessageXSent",
                    new Object[]{new Integer(sent)});
        }
        syncEventInfo.setInfoCode(SyncEventInfo.MESSAGE_SENT);
        syncEventInfo.infoMessage = userInfoMessage;
        update(syncEventInfo);
         */
    }
    
    
    /**
     * should be called when a message session ends
     *@param status the status as returned by the server
     *
     */
    public void endSession(int status) {
        
        if (status != AccountListener.STATUS_SUCCESS) {
            userInfoMessage = getErrorMessage(status);
        }  else {
            userInfoMessage = Localization.getMessages().getX_MESSAGES_RECEIVED(received);
        }

        syncEventInfo.setInfoCode(SyncEventInfo.END_MESSAGE_SESSION);
        syncEventInfo.infoMessage = userInfoMessage;
        update(syncEventInfo);
    }
    
    /**
     * Should be called when receiving is started
     *
     *
     * @param number The number of userInfoMessage to be received, or
     *               AccountListener.MESSAGE_NUMBER_UNKNOWN if unknown
     */
    public void startReceiving(int number) {
        toReceive = number;
        /*
        if (toReceive != AccountListener.MESSAGE_NUMBER_UNKNOWN) {
            userInfoMessage = Localization.getMessages("incoming_messages",
                    new Object[]{new Integer(number)});
        }
        syncEventInfo.setInfoCode(SyncEventInfo.START_RECEIVE);
        syncEventInfo.infoMessage = userInfoMessage;
        update(syncEventInfo);
         */
    }
    
    /**
     * should be called when started sending.
     *
     * @param the number of userInfoMessage to be sent,
     * or AccountListener.MESSAGE_NUMBER_UNKNOWN if
     * unknown
     */
    public void startSending(int number) {
        Log.debug(this, " #########################    Start sending " + number);
        
        toSend = number;
        
        //if we have something to send
        if (toSend != 0) {// && toSend != AccountListener.MESSAGE_NUMBER_UNKNOWN) {
            if (toSend == AccountListener.MESSAGE_NUMBER_UNKNOWN) {
                userInfoMessage = Localization.getMessages().SENDING_DOTTED;
            } else if (toSend > 0) {
                userInfoMessage = Localization.getMessages().getSENDINGX(toSend);
            }
            syncEventInfo.setInfoCode(SyncEventInfo.START_SEND);
            syncEventInfo.infoMessage = userInfoMessage;
            update(syncEventInfo);
        }
        
        
        
    }
    
    /**
     * should be called when finished sending
     */
    public void endSending() {
        //TODO
    }
    
    /*
     * calculate and update progress
     *
    private void updateProgress() {
        progress = 0;
     
        if (connected)
            progress += MAX/4;
     
        // if we've sent at least one item
        if (sent > 0 || toSend >= 0)
            if (sent < toSend)
                //if we know the % of sent userInfoMessage we use it to
                //set the progress
                progress += (sent/toSend) * MAX/4;
            else //we increment the progress by 25%
                progress += MAX/4;
        else
            if (received > 0)
                progress += MAX/4;
     
        if (received>0||toReceive>=0)
            if (received < toReceive)
                progress += (received/toReceive) * MAX/4;
            else
                progress += MAX/4;
     
        if (completed)
            progress = MAX;
    }
     */
    
    public void msgDeleted(String msgId) {
        Log.debug("delete notification from server for message " + msgId);
        syncEventInfo.setInfoCode(syncEventInfo.MESSAGE_DELETED);
        syncEventInfo.msgId = msgId;
        update(syncEventInfo);
    }
    
    public void msgFlagsUpdated(String msgId, MessageFlags newFlags) {
        Log.debug("update notification from server for message " + msgId);
        syncEventInfo.setInfoCode(syncEventInfo.MESSAGE_FLAGS_UPDATED);
        syncEventInfo.msgId = msgId;
        syncEventInfo.flags = newFlags;
        update(syncEventInfo);
    }
    
    public void reset() {
        int prevNumObservers = numObservers;
        super.reset();
        observer = new Observer[prevNumObservers];
        toReceive = AccountListener.MESSAGE_NUMBER_UNKNOWN;
        toSend = AccountListener.MESSAGE_NUMBER_UNKNOWN;
        received = 0;
        sent = 0;
        connected = false;
        completed = false;
        resetContacts = true;
        max = MAX;
        syncEventInfo = new SyncEventInfo();
        mm.setListener(this);
        this.syncMode = -1;
    }
    
    
    public boolean isSyncMessages() {
        return syncMessages;
    }
    
    /**
     * choose if the run will perform a sync of the messages
     *
     */
    public void setSyncMessages(boolean syncInbox) {
        this.syncMessages = syncInbox;
    }
    
    
}