/*

* Copyright (c) 2002-2005 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: Timers assemble for imps engine base function.

*

*               CImpsIdleTimer

*               Idle timer to lauch Poll requests in CSP protocol.

*               CImpsPDPIdleTimer

*               Idle timer to close idle PDP-context (IAP).

*               CImpsPDPOpenTimer

*               Timer to open idle PDP-context.

*               CImpsShutdownTimer

*               Idle timer to lauch keep-alive and Poll requests in CSP protocol.

*

*/

// INCLUDE FILES

#include    <e32std.h>

#include    <flogger.h>

#include    "impsutils.h"

#include    "impsTimer.h"

#include    "ImpsServer.h"

// MACROS

#ifndef _DEBUG

#define _NO_IMPS_LOGGING_

#endif

const TInt KImpsUseAfterLimit = 240;

//**********************************

// CImpsBaseTimer

//**********************************

CImpsBaseTimer::CImpsBaseTimer(

    TInt aPriority )

        : CActive( aPriority ),

        iReset( EFalse )

    {

    // Add this to the scheduler

    ( void ) iTimer.CreateLocal();

    CActiveScheduler::Add( this );

    }

CImpsBaseTimer::~CImpsBaseTimer()

    {

    Cancel();

    iTimer.Close();

    }

// -----------------------------------------------------------------------------

// CImpsBaseTimer::Start

// -----------------------------------------------------------------------------

void CImpsBaseTimer::Start( TInt aWaitSeconds )

    {

    iReset = EFalse;

    // Cancel is needed because of the timer may be reset.

    Cancel();

    if ( aWaitSeconds <= 0 )

        {

        return;

        }

    iSeconds = aWaitSeconds;

    // The At function caused a CUserbase-Panic 46 in very small

    // time values. 1-4 seconds. Now if the KeepAlive time

    // is smaller than UseAfterLimit, then we use the After function

    // If it is larger then use the At function

    // The reason not to use the After function for every situation is

    // that the TInt overflows after 35 minutes. 1000000*60*36 > 2^31

    if ( iSeconds <= KImpsUseAfterLimit )

        {

        iTimer.After( iStatus, iSeconds * 1000000 );

        }

    else

        {

        TTime myKeepAlive;

        myKeepAlive.HomeTime();

        myKeepAlive += TTimeIntervalSeconds( iSeconds );

        iTimer.At( iStatus, myKeepAlive );

        }

    iStatus = KRequestPending;

    SetActive();

    }

// -----------------------------------------------------------------------------

// CImpsBaseTimer::Stop

// -----------------------------------------------------------------------------

void CImpsBaseTimer::Stop( )

    {

    iReset = ETrue;

    Cancel();

    }

// -----------------------------------------------------------------------------

// CImpsBaseTimer::Reset

// -----------------------------------------------------------------------------

void CImpsBaseTimer::Reset( )

    {

    // Avoid continuos cancelling, therefore just set flag on

    iReset = ETrue;

    }

// -----------------------------------------------------------------------------

// CImpsBaseTimer::DoCancel

// -----------------------------------------------------------------------------

void CImpsBaseTimer::DoCancel()

    {

    iTimer.Cancel();

    }

//**********************************

// CImpsIdleTimer

//**********************************

CImpsIdleTimer::CImpsIdleTimer(

    MImpsCSPSession& aServer,

    TInt aPriority )

        : CImpsBaseTimer( aPriority ),

        iServer( aServer )

    {

    }

CImpsIdleTimer::~CImpsIdleTimer()

    {

    }

// -----------------------------------------------------------------------------

// CImpsIdleTimer::Start

// -----------------------------------------------------------------------------

void CImpsIdleTimer::Start( TInt aWaitSeconds )

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "CImpsIdleTimer: Start sec=%d" ), aWaitSeconds );

#endif

    CImpsBaseTimer::Start( aWaitSeconds );

    }

// -----------------------------------------------------------------------------

// CImpsIdleTimer::Stop

// -----------------------------------------------------------------------------

void CImpsIdleTimer::Stop()

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "CImpsIdleTimer: Stop" ) );

#endif

    CImpsBaseTimer::Stop();

    }

// -----------------------------------------------------------------------------

// CImpsIdleTimer::RunL

// -----------------------------------------------------------------------------

void CImpsIdleTimer::RunL()

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "IdleTimer: RunL" ) );

#endif

    TInt err = KErrNone;

    TRAP( err, iServer.SendPollL() );

    Start( iSeconds );

    }

//**********************************

// CImpsPDPIdleTimer

//**********************************

CImpsPDPIdleTimer::CImpsPDPIdleTimer(

    MImpsCSPSession& aServer,

    TInt aPriority )

        : CImpsBaseTimer( aPriority ),

        iServer( aServer )

    {

    }

CImpsPDPIdleTimer::~CImpsPDPIdleTimer()

    {

    }

// -----------------------------------------------------------------------------

// CImpsPDPIdleTimer::Reset

// -----------------------------------------------------------------------------

void CImpsPDPIdleTimer::Reset( )

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "CImpsPDPIdleTimer: Reset" ) );

#endif

    // Reset re-starts this timer only if already runnig

    if ( IsActive() )

        {

        CImpsBaseTimer::Start( iSeconds );

        }

    }

// -----------------------------------------------------------------------------

// CImpsPDPIdleTimer::Start

// -----------------------------------------------------------------------------

void CImpsPDPIdleTimer::Start( TInt aWaitSeconds )

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "CImpsPDPIdleTimer: Start sec =%d" ), aWaitSeconds );

#endif

    CImpsBaseTimer::Start( aWaitSeconds );

    }

// -----------------------------------------------------------------------------

// CImpsPDPIdleTimer::Stop

// -----------------------------------------------------------------------------

void CImpsPDPIdleTimer::Stop()

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "CImpsPDPIdleTimer: Stop" ) );

#endif

    CImpsBaseTimer::Stop();

    }

// -----------------------------------------------------------------------------

// CImpsPDPIdleTimer::RunL

// -----------------------------------------------------------------------------

void CImpsPDPIdleTimer::RunL()

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "PDPIdleTimer: RunL" ) );

#endif

    // This timer only calls ClosePDP()

    if ( iStatus.Int() != KErrCancel )

        {

        iServer.ClosePDP();

        }

    iReset = EFalse;

    Start( iSeconds );

    }

//**********************************

// CImpsPDPOpenTimer

//**********************************

CImpsPDPOpenTimer::CImpsPDPOpenTimer(

    MImpsCSPSession& aServer,

    TInt aPriority )

        : CImpsBaseTimer( aPriority ),

        iServer( aServer )

    {

    }

CImpsPDPOpenTimer::~CImpsPDPOpenTimer()

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "CImpsPDPOpenTimer: DELETE" ) );

#endif

    }

// -----------------------------------------------------------------------------

// CImpsPDPOpenTimer::Start

// -----------------------------------------------------------------------------

void CImpsPDPOpenTimer::Start( TInt aWaitSeconds )

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "CImpsPDPOpenTimer: Start sec=%d" ), aWaitSeconds );

#endif

    CImpsBaseTimer::Start( aWaitSeconds );

    }

// -----------------------------------------------------------------------------

// CImpsPDPOpenTimer::Stop

// -----------------------------------------------------------------------------

void CImpsPDPOpenTimer::Stop()

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "CImpsPDPOpenTimer: Stop" ) );

#endif

    CImpsBaseTimer::Stop();

    }

// -----------------------------------------------------------------------------

// CImpsPDPOpenTimer::RunL

// -----------------------------------------------------------------------------

void CImpsPDPOpenTimer::RunL()

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "CImpsPDPOpenTimer: RunL" ) );

#endif

    if ( iStatus.Int() != KErrCancel )

        {

        TInt ret = iServer.OpenPDP();

        // if already open then do not start

        if ( ret == KErrAlreadyExists )

            {

#ifndef _NO_IMPS_LOGGING_

            CImpsClientLogger::Log( _L( "CImpsPDPOpenTimer: not started anymore ***" ) );

#endif

            return;

            }

        }

    Start( iSeconds );

    }

//**********************************

// CImpsShutdownTimer

//**********************************

CImpsShutdownTimer::CImpsShutdownTimer(

    CImpsServer& aServer,

    TInt aPriority )

        : CImpsBaseTimer( aPriority ),

        iServer( aServer )

    {

    }

CImpsShutdownTimer::~CImpsShutdownTimer()

    {

    iStatus = KErrNone;

    }

// -----------------------------------------------------------------------------

// CImpsShutdownTimer::RunL

// -----------------------------------------------------------------------------

void CImpsShutdownTimer::RunL()

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "ShutDownTimer: RunL" ) );

#endif

    if ( iStatus != KErrNone )

        {

#ifndef _NO_IMPS_LOGGING_

        CImpsClientLogger::Log( _L( "ShutDownTimer: RunL ignored" ) );

#endif

        return;

        }

    if ( !iReset )

        {

        iServer.DoShutDown();

        }

    // It is extremely important that after the previous call this

    // method does nothing since DoShutDown actully deletes the

    // current entity if this class!

    }

// -----------------------------------------------------------------------------

// CImpsShutdownTimer::Stop

// -----------------------------------------------------------------------------

void CImpsShutdownTimer::Stop()

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "ShutDownTimer: Stop" ) );

#endif

    CImpsBaseTimer::Stop();

    }

// -----------------------------------------------------------------------------

// CImpsShutdownTimer::Start

// -----------------------------------------------------------------------------

void CImpsShutdownTimer::Start( TInt aWaitSeconds )

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "ShutDownTimer: Start sec=%d" ), aWaitSeconds );

#endif

    Cancel();

    if ( !aWaitSeconds )

        {

        // Do the shut down ASAP

        iStatus = KRequestPending;

        SetActive();

        iReset = EFalse;

        TRequestStatus* s = &iStatus;

        User::RequestComplete( s, KErrNone );

#ifndef _NO_IMPS_LOGGING_

        CImpsClientLogger::Log( _L( "ShutDownTimer: RequestComplete" ) );

#endif

        }

    else

        {

#ifndef _NO_IMPS_LOGGING_

        CImpsClientLogger::Log( _L( "ShutDownTimer: BaseTimer:Start begins" ) );

#endif

        CImpsBaseTimer::Start( aWaitSeconds );

        }

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "ShutDownTimer: Start ends" ) );

#endif

    }

//**********************************

// CImpsExpiryTimer

//**********************************

CImpsExpiryTimer::CImpsExpiryTimer(

    CImpsServer& aServer,

    TImpsEventType aType,

    TInt aPriority )

        : CImpsBaseTimer( aPriority ),

        iServer( aServer ),

        iType ( aType )

    {

    }

CImpsExpiryTimer::~CImpsExpiryTimer()

    {

    }

// -----------------------------------------------------------------------------

// CImpsExpiryTimer::Start

// -----------------------------------------------------------------------------

void CImpsExpiryTimer::Start( TInt aWaitSeconds )

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "CImpsExpiryTimer: Start sec=%d" ), aWaitSeconds );

#endif

    CImpsBaseTimer::Start( aWaitSeconds );

    }

// -----------------------------------------------------------------------------

// CImpsExpiryTimer::Stop

// -----------------------------------------------------------------------------

void CImpsExpiryTimer::Stop()

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "CImpsExpiryTimer: Stop" ) );

#endif

    CImpsBaseTimer::Stop();

    }

// -----------------------------------------------------------------------------

// CImpsExpiryTimer::RunL

// -----------------------------------------------------------------------------

void CImpsExpiryTimer::RunL()

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "ExpiryTimer: RunL" ) );

#endif

    if ( iStatus == KErrNone )

        {

        iServer.CheckExpiryL( iType );

        iTimer.After( iStatus, iSeconds * 1000000 );

        SetActive();

        }

    else

        {

#ifndef _NO_IMPS_LOGGING_

        CImpsClientLogger::Log( _L( "ExpiryTimer: RunL ignored" ) );

#endif

        }

    }

//**********************************

// CImpsSendQueued

//**********************************

CImpsSendQueued::CImpsSendQueued(

    MImpsCSPSession& aServer,

    TInt aPriority )

        : CActive( aPriority ),

        iServer( aServer ),

        iCanceled ( EFalse )

    {

    // Add this to the scheduler

    CActiveScheduler::Add( this );

    }

CImpsSendQueued::~CImpsSendQueued()

    {

    Cancel();

    }

// -----------------------------------------------------------------------------

// CImpsSendQueued::Send

// -----------------------------------------------------------------------------

void CImpsSendQueued::Send(  )

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "SendQueued: Send" ) );

#endif

    // This yields the control to the server thread active scheduler

    if ( !IsActive() )

        {

        iStatus = KRequestPending;

        SetActive();

        iCanceled = EFalse;

        TRequestStatus* s = &iStatus;

        User::RequestComplete( s, KErrNone );

        }

    }

// -----------------------------------------------------------------------------

// CImpsSendQueued::DoCancel

// -----------------------------------------------------------------------------

void CImpsSendQueued::DoCancel()

    {

    iCanceled = ETrue;

    }

// -----------------------------------------------------------------------------

// CImpsSendQueued::RunL

// -----------------------------------------------------------------------------

void CImpsSendQueued::RunL()

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "SendQueued: RunL" ) );

#endif

    if ( iCanceled || iStatus.Int() != KErrNone )

        {

        return;

        }

    // Trigger a server thread to send a queued message

    TInt errx = KErrNone;

    TRAP( errx, iServer.DoSendAllQueuedL() );

    }

//  End of File