/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
* Implementation of EmailServerMonitor
*
*/

//  Include Files  
#include <e32base.h>
#include <e32std.h>
#include <e32des16.h>                   // Descriptors
#include <apacmdln.h>
#include <apgcli.h>

#include <AlwaysOnlineManagerClient.h>  // RAlwaysOnlineClientSession
#include <CPsRequestHandler.h>          // CPSRequestHandler

#include "emailtrace.h"
#include "emailservermonitorutilities.h"
#include "emailservermonitor.h"
#include "emailservermonitorconst.h"
#include "emailshutter.h"

const TUint KOneSecondInMicroSeconds = 1000000;

const TInt KExternalServiceRestartDelay = 5 * KOneSecondInMicroSeconds;
const TInt KInstallatioFinishedFlagSettingDelay = 2 * KOneSecondInMicroSeconds;

// ======== MEMBER FUNCTION DEFINITIONS ========

/**
 * Two-phased class constructor.
 */
CEmailServerMonitor* CEmailServerMonitor::NewL()
    {
    FUNC_LOG;
    CEmailServerMonitor* self = CEmailServerMonitor::NewLC();
    CleanupStack::Pop( self );
    return self;
    }

/**
 * Two-phased class constructor.
 */
CEmailServerMonitor* CEmailServerMonitor::NewLC()
    {
    FUNC_LOG;
    CEmailServerMonitor* self = new (ELeave) CEmailServerMonitor();
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }
    
/**
 * Destructor of CEmailServerMonitor class.
 */
CEmailServerMonitor::~CEmailServerMonitor()
    {
    FUNC_LOG;
    iApaLsSession.Close();
    iProcess.Close();
    iDelayTimer.Close();
    if( iExternalServiceRestartTimer )
        {
        delete iExternalServiceRestartTimer;
        iExternalServiceRestartTimer = NULL;
        }
    }
    
/**
 * Default class constructor.
 * Only NewL can be called
 */
CEmailServerMonitor::CEmailServerMonitor()
    : CActive( EPriorityStandard ),
      iState( EEsmStateIdle ),
      iRestarts( 0 ),
      iShutter( NULL ),
      iExternalServicesRestartState( EEsmEsrStateRestartNotNeeded )
    {
    FUNC_LOG;
    }
    
/**
 * Second phase class constructor.
 */
void CEmailServerMonitor::ConstructL()
    {
    FUNC_LOG;
    User::LeaveIfError( iApaLsSession.Connect() );
    User::LeaveIfError( iDelayTimer.CreateLocal() );
    
    CActiveScheduler::Add(this);
    }
    
/**
 * Start email server monitoring.
 */
void CEmailServerMonitor::Start()
    {
    FUNC_LOG;
    iLastRestartTime.UniversalTime();
    
    // Initiate delayed restart and set correct state
    InitiateDelayedRestart();
    iState = EEsmStateInitializing;
    }

/**
 * Set pointer to shutter.
 */
void CEmailServerMonitor::SetShutter( CEmailShutter* aShutter )
    {
    iShutter = aShutter;
    }

/**
 * Set Restart External Services flag.
 */
void CEmailServerMonitor::SetRestartExternalServicesFlag( TBool aRestartFlag /*= ETrue*/ )
    {
    if( aRestartFlag )
        {
        iExternalServicesRestartState = EEsmEsrStateRestartNeeded;
        }
    else
        {
        iExternalServicesRestartState = EEsmEsrStateRestartNotNeeded;
        }
    }

/**
 * Called when external service restart timer has expired, so it's time to do
 * some starting
 */
void CEmailServerMonitor::TimerEventL( CEmailServerMonitorTimer* /*aTriggeredTimer*/ )
    {
    // Shutter is used in all cases, so verify it exists at the beginning
    if( iShutter )
        {
        switch( iExternalServicesRestartState )
            {
            case EEsmEsrStateRestartInitiated:
                {
                // Restart external services and change state
                iShutter->RestartServicesAfterInstallation();
                iExternalServicesRestartState = EEsmEsrStateFirstServiceRestarted;
                
                // Restart the timer to set the installation finished flag
                // with some more delay
                iExternalServiceRestartTimer->Start( KInstallatioFinishedFlagSettingDelay );
                }
                break;
                
            case EEsmEsrStateFirstServiceRestarted:
                {
                // Set the installation finished flag and clear state variable
                iShutter->SetPsKeyInstallationFinished();
                iExternalServicesRestartState = EEsmEsrStateRestartNotNeeded;
                }
                break;
                
            default:
                // Do nothing, shouldn't happen
                break;
            }
        }
    }

/**
 * Start Email Server and start monitoring it
 */
TBool CEmailServerMonitor::StartEmailServerMonitoring()
    {
    FUNC_LOG;
    // Give iProcess as parameter for IsProcessRunning so that it will
    // be updated in case that the Email Server process is running.
    TBool running = IsProcessRunning( KEmailServerUid, &iProcess );
	
    // Start Email Server if it's not yet running
    if( !running )
        {
        iRestarts++;
        
        TThreadId threadId;
        TRequestStatus reqStatusForRendezvous;
        TRAPD( error, StartApplicationL( KEmailServerExe(), threadId, reqStatusForRendezvous ) );
        
        // If application was started succesfully
        if( error == KErrNone )
            {
            User::WaitForRequest( reqStatusForRendezvous );
            
            // If process started succesfully, we are ready for observing
            if( reqStatusForRendezvous.Int() == KErrNone )
                {
                // Close previous process handle
                iProcess.Close();
                
                // Get handle to newly created process using the threadId
                RThread thread;
                TInt error = thread.Open( threadId );
                if( error == KErrNone )
                    {
                    error = thread.Process( iProcess );
                    thread.Close();
                    // Indicate success only if iProcess update succeeded, as it's
                    // assumed to be up-to-date if Email Server process is running
                    if( error == KErrNone )
                        {
                        running = ETrue;
                        }
                    }
                }
            }
        }
    
    if( running )
        {
        DoStartMonitoring();
        }
    else
        {
        INFO( "Restart failed!" );
        }
    
    return running;
    }

/**
 * Starts the actual monitoring. Assumes that Email Server is running
 * and Monitor's internal variables are set accordingly.
 */
void CEmailServerMonitor::DoStartMonitoring()
    {
    FUNC_LOG;
    SetActive();
    iProcess.Logon( iStatus );
    iState = EEsmStateMonitoring;
    }

/**
 * Start specified application, leaves if failed to start the application
 */
void CEmailServerMonitor::StartApplicationL(
        const TDesC& aAppName,
        TThreadId& aThreadId,
        TRequestStatus& aReqStatusForRendezvous )
    {
    CApaCommandLine* cmdLine = CApaCommandLine::NewLC();
    cmdLine->SetExecutableNameL( aAppName );
    // Launch Email Server in background so that it doesn't steal
    // the focus during it's construction
    cmdLine->SetCommandL( EApaCommandBackground );
    
    User::LeaveIfError( iApaLsSession.StartApp( *cmdLine, aThreadId, &aReqStatusForRendezvous ) );
    
    CleanupStack::PopAndDestroy( cmdLine );
    }

/**
 * DoCancel of active object
 */
void CEmailServerMonitor::DoCancel()
    {
    FUNC_LOG;
    iState = EEsmStateIdle;
    iProcess.LogonCancel( iStatus );
    iDelayTimer.Cancel();
    if( iExternalServiceRestartTimer )
        {
        iExternalServiceRestartTimer->Cancel();
        }
    }

/**
 * RunL of active object
 */
void CEmailServerMonitor::RunL()
    {
    FUNC_LOG;
    
    INFO_1( "iStatus: %d", iStatus.Int() );
    INFO_1( "iState: %d", iState );

    switch( iState )
        {
        case EEsmStateMonitoring:
            {
            // Write the process exit information to the debug log.
            INFO_1( "ExitType: %d", iProcess.ExitType() );
            INFO_1( "ExitReason: %d", iProcess.ExitReason() );
            HandleMonitorEvent();
            }
            break;
            
        case EEsmStateInitializing:
        case EEsmStateRestarting:
            {
            // Restart Email server and start monitoring it again
            if( !StartEmailServerMonitoring() )
                {
				// If start failed initiate new delayed restart
                INFO( "Initiating new delayed restart" );
                InitiateDelayedRestart();
                }
            // If Email server is up and running and iExternalServicesRestartState
            // flag is set, initiate delayed restart of external services
            else if( iExternalServicesRestartState == EEsmEsrStateRestartNeeded )
                {
                // Once restart is initiated, update the state
                iExternalServicesRestartState = EEsmEsrStateRestartInitiated;

                // Create the timer and start it
                TInt timerError = KErrNone;
                if( !iExternalServiceRestartTimer )
                    {
                    TRAP( timerError, iExternalServiceRestartTimer = CEmailServerMonitorTimer::NewL( this ) );
                    }
                if( timerError == KErrNone )
                    {
                    iExternalServiceRestartTimer->Start( KExternalServiceRestartDelay );
                    }
                }
            }
            break;
            
        case EEsmStateIdle:
        default:
            {
            // Shouldn't happen
            INFO( "Unknown state or not observing!" );
            }
        }
    }

/**
 * Handle email server monitoring event
 */
void CEmailServerMonitor::HandleMonitorEvent()
    {
    FUNC_LOG;
    TExitType exitType = iProcess.ExitType(); 
    if ( exitType == EExitPanic )
        {
        INFO( "Initiating delayed restart of Email Server" );
        InitiateDelayedRestart();
        }
    else if ( exitType == EExitPending )
        {
        INFO( "Process is still alive, restarting monitoring" );
        DoStartMonitoring();
        }
    else
        {
        INFO( "Email Server terminated, not restarting!" );
        iState = EEsmStateIdle;
        }
    }

/**
 * Initiate an asynchronous delayed restart
 */
void CEmailServerMonitor::InitiateDelayedRestart()
    {
    FUNC_LOG;
    TTime now;
    now.UniversalTime();
    
    // Calculate minutes from last restart
    TTimeIntervalMinutes minutesSinceLastRestart = 0;
    now.MinutesFrom( iLastRestartTime, minutesSinceLastRestart );
    INFO_1( "Minutes since last restart=%d", minutesSinceLastRestart.Int() );
    
    iLastRestartTime = now;
    
    // If the process has been running successfully long enough then reset
    // the restart counter.
    if( minutesSinceLastRestart >= TTimeIntervalMinutes( KEsmUptimeToResetRestartCounter ) )
        {
        INFO( "Long enough uptime, reset restart counter" );
        iRestarts = 0;
        }

    // Initiate new delayed restart, if restart limit is not exceeded
    if( iRestarts < KEsmMaxRestarts )
        {
        iDelayTimer.After( iStatus, KEsmRestartDelayInSeconds * KOneSecondInMicroSeconds );
        SetActive();
        iState = EEsmStateRestarting;
        }
    else
        {
        INFO( "Maximum restarts exceeded!" );
        iState = EEsmStateIdle;
        }
    }