/*

* Copyright (c) 2003 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:  Observer of System Agent events

*

*/

// INCLUDE FILES

#include <es_sock.h>

#include <syevdef.h>

// User Includes

#include "httpfilterConnHandlerObserver.h"

#include "mconnectioncallback.h"

#include <flogger.h>

_LIT(KDir, "connFilter");

_LIT(KFile, "filtererr.txt");

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

const TInt KMaxOutOfCoverageTime   = 60*1000000;  //60 sec - Updated to 60 secs as part of error fix JSIN-7JSE6H

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ===============================

// ============================ MEMBER FUNCTIONS ===============================

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

// CHttpFilterConnHandlerObserver::CHttpFilterConnHandlerObserver

// C++ default constructor can NOT contain any code, that

// might leave.

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

CHttpFilterConnHandlerObserver::CHttpFilterConnHandlerObserver(MConnectionCallback* aConnCallback):

        CActive(CActive::EPriorityHigh),iConnCallback(aConnCallback)

{

    CActiveScheduler::Add(this);

    iState = EIdle;

}

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

// CHttpFilterConnHandlerObserver::ConstructL

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

void CHttpFilterConnHandlerObserver::ConstructL()

{

    iSuspendTimer = CPeriodic::NewL(CActive::EPriorityLow );

}

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

// CHttpFilterConnHandlerObserver::NewL

//

// Creats an instance of the CHttpFilterConnHandlerObserver

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

CHttpFilterConnHandlerObserver* CHttpFilterConnHandlerObserver::NewL(MConnectionCallback* aConnCallback)

{

    CHttpFilterConnHandlerObserver* self = new( ELeave ) CHttpFilterConnHandlerObserver(aConnCallback);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

}

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

// CHttpFilterConnHandlerObserver::~CHttpFilterConnHandlerObserver

//

// Destructor

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

CHttpFilterConnHandlerObserver::~CHttpFilterConnHandlerObserver()

{

    Cancel();

    iSysAgent.Close();

    if ( iSuspendTimer )

        iSuspendTimer->Cancel();

    delete iSuspendTimer;

}

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

// CHttpFilterConnHandlerObserver::DoCancel

//

// Cancellation of notify.

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

void CHttpFilterConnHandlerObserver::DoCancel()

{

    iSysAgent.NotifyEventCancel();

}

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

// CHttpFilterConnHandlerObserver::RunL

//

// This method will be called when registred System Agent event occures

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

void CHttpFilterConnHandlerObserver::RunL()

{

    TInt state = iSysAgentEvent.State();

    TUid uid   = iSysAgentEvent.Uid();

    if(iStatus.Int() == KErrNone)

    {

        IssueRequest();

        HandleSystemAgentEventL( uid, state );

    }

}

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

// CHttpFilterConnHandlerObserver::IssueRequest

//

// Issue notify request to the System agent.

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

void CHttpFilterConnHandlerObserver::IssueRequest()

{

    iSysAgent.NotifyOnEvent(iSysAgentEvent);

    SetActive();

}

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

// CHttpFilterConnHandlerObserver::SetRequestStatus

//

// Sets the object's request status to refer to the specified request status object

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

void CHttpFilterConnHandlerObserver::SetRequestStatus()

{

    iSysAgentEvent.SetRequestStatus(iStatus);

}

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

// CHttpFilterConnHandlerObserver::SysAgentConnectL

//

// Connect to System Agent

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

void CHttpFilterConnHandlerObserver::SysAgentConnectL()

{

    User::LeaveIfError(iSysAgent.Connect());

}

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

// CHttpFilterConnHandlerObserver::SysAgentSetUid

//

// Set System Agent Uid

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

void CHttpFilterConnHandlerObserver::SysAgentSetUid(TUid aUid)

{

    iSysAgentEvent.SetUid(aUid);

}

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

// CHttpFilterConnHandlerObserver::SysAgentGetState

//

// Get state

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

void CHttpFilterConnHandlerObserver::SysAgentGetState(TUid aUid, TInt& aState)

{

    TInt state = iSysAgent.GetState(aUid);

    aState = state;

}

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

// CHttpFilterConnHandlerObserver::SetState

//

// Set iRequested data member

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

void CHttpFilterConnHandlerObserver::SetState(TInt aState)

{

    iState = aState;

}

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

// CHttpFilterConnHandlerObserver::GetState

//

// Set iRequested data member

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

void CHttpFilterConnHandlerObserver::GetState(TInt& aState)

{

    aState = iState;

}

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

// CHttpFilterConnHandlerObserver::HandleSystemAgentEventL

//

// This method will be called when registred System Agent event occures

// In case of GPRS:

//	ESAGprsUnattached,

//	ESAGprsAttach,

//	ESAGprsContextActive,

//	ESAGprsSuspend,

//	ESAGprsContextActivating,

//	ESAGprsMultibleContextActive

// Handle System Agent events

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

void CHttpFilterConnHandlerObserver::HandleSystemAgentEventL( TUid aUid, TInt aState )

{

    RFileLogger::WriteFormat(KDir, KFile, EFileLoggingModeAppend, _L8("GPRS %d"), aState);

    RFileLogger::WriteFormat(KDir, KFile, EFileLoggingModeAppend, _L8("Obs state %d"), iState);

    // Request should be issued in order to get notification for the next event

    // handle GPRS bearer type

    if (aUid == KUidGprsStatus)

    {

        switch (aState)

        {

        case ESAGprsSuspend:

            if (iState == EActiveReady)

            {

                // start the timer. If the ESAGprsContextActive event will not occure

                // before the timer expired the

                // current transaction will be canceled and the user will be notified.

                iSuspendTimer->Cancel();

                iSuspendTimer->Start(

                    KMaxOutOfCoverageTime,

                    0,  // No interval

                    TCallBack( TimerSuspendCallback, this ) );

                iState = ESuspended;

            }

            break;

        case ESAGprsUnattached:

            if (iState == ESuspended)

            {

                iSuspendTimer->Cancel();

                iConnCallback->CoverageEvent(EErrWaitTimeout);

                iState = EIdle;

            }

            break;

        case ESAGprsContextActive:

            if (iState == ESuspended)

            {

                // Signal came back, so just stop a timer

                iSuspendTimer->Cancel();

                iState = EActiveReady;

            }

            break;

        default:

            break;

        } //switch

    }

}

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

// CHttpFilterConnHandlerObserver::DoTimerSuspend

// callback function for the TimerSuspended

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

//

void CHttpFilterConnHandlerObserver::DoTimerSuspend()

{

    iSuspendTimer->Cancel();

    if (iState == ESuspended)

    {

        iState = EIdle;

        iConnCallback->CoverageEvent(EErrWaitTimeout);

        RFileLogger::WriteFormat(KDir, KFile, EFileLoggingModeAppend, _L8("CTimer:Event"));

    }

}

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

// CHttpFilterConnHandlerObserver::TimerSuspendCallback

// callback function for the TimerSuspended

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

//

TInt CHttpFilterConnHandlerObserver::TimerSuspendCallback(TAny* aAny )

{

    ((CHttpFilterConnHandlerObserver*)aAny)->DoTimerSuspend();

    return KErrNone;

}

//  End of File