/*

* Copyright (c) 2003-2006 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 CCoUtlActive.

*

*/

// INCLUDE FILES

#include    "CCoUtlActive.h"

#include    <mmtsy_names.h>

#include    <nifvar.h>

#include    <pcktcs.h>

#include    <AknGlobalConfirmationQuery.h>

#include    <AknUtils.h>

#include    <StringLoader.h>

#include    <connectutilrsc.rsg>

#include    <avkon.hrh>

#include    <e32property.h>

#include    <PSVariables.h>

// CONSTANTS

// Panic category.

_LIT( KCoUtlPanicCategory, "CoUtl" );

// Enumerates panic reasons

enum 

    {

    // Terminate is already called and operation has not been completed yet. 

    // Cancel before calling Terminate.

    ECoUtlPanicTerminateAlreadyActive = 0

    };

// MACROS

#if defined _DEBUG && !defined __WINS__

// Target UDEB environment - debug traces enabled

#define COUTL_RDEBUG(X)             RDebug::Print(X);

#define COUTL_RDEBUG_INT(X,Y)       RDebug::Print(X,Y);

#else           

// Other environments - debug traces disabled

#define COUTL_RDEBUG(X)

#define COUTL_RDEBUG_INT(X,Y)

#endif

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

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

// CCoUtlActive::CCoUtlActive

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

// might leave.

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

//

CCoUtlActive::CCoUtlActive()

    : CActive( CActive::EPriorityStandard )

    {

    CActiveScheduler::Add( this );

    }

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

// CCoUtlActive::~CCoUtlActive

// Destructor.

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

//

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

*   Series 60 Customer / ETel 

*   Series 60  ETel API 

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

CCoUtlActive::~CCoUtlActive()

    {

    Cancel();

    if ( iServer.Handle() )

        {

        // Error is ignored - loading might have failed.

        iServer.UnloadPhoneModule( KMmTsyModuleName ); 

        }

    delete iConfirmationQuery;

    delete iConfirmationText;

    iConnections.Close();

    iPacketService.Close();

    iMobilePhone.Close();

    iServer.Close();

    iConnectionMonitor.CancelNotifications();

    iConnectionMonitor.Close();

    }

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

// CCoUtlActive::CurrentState

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

//

CCoUtlActive::TState CCoUtlActive::CurrentState() const

    {

    return iState;

    }

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

// CCoUtlActive::Start

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

//

void CCoUtlActive::Start( TRequestStatus& aStatus )

    {

    if ( !IsActive() )

        {

        aStatus = KRequestPending;

        iRequestStatus = &aStatus;

        GoToStateAndComplete( EStarted );

        }

    else

        {

        User::Panic( KCoUtlPanicCategory, ECoUtlPanicTerminateAlreadyActive );

        }

    }

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

// CCoUtlActive::RunL

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

//

void CCoUtlActive::RunL()

    {

    COUTL_RDEBUG_INT( _L("CCoUtlActive::RunL - State %d: "), iState )

    COUTL_RDEBUG_INT( _L("CCoUtlActive::RunL - Status %d: "), iStatus.Int() )

    // Clean up parameters that might require uninitialisation.

    delete iConfirmationQuery;

    iConfirmationQuery = NULL;

    delete iConfirmationText;

    iConfirmationText = NULL;

    // Leave in case of error.

    User::LeaveIfError( iStatus.Int() );

    // Handle state transitions.

    switch ( iState )

        {

        case EStarted:

            iConnections.Reset();

            GetAttachStatusL();

            break;

        case ECheckIfAttached:

            if ( IsAttached() )

                {

                GetConnectionCountL();

                }

            break;

        case EGetConnectionCount:

            iConnectionsIndex = 0;

            CheckConnectionsL();

            break;

        case EGoThroughConnections:

            if ( iConnectionsIndex < iConnections.Count() )

                {

                GoThroughConnectionsGetBearerL();

                }

            else

                {

                GetNetworkModeL();

                }

            break;

        case EGoThroughConnectionsGetBearer:

            if ( AcceptConnectionBearer() )

                {

                GoThroughConnectionsGetStatusL();

                }

            else

                {

                // Not accepted - delete and continue to the next.

                iConnections.Remove( iConnectionsIndex );

                GoToStateAndComplete( EGoThroughConnections );

                }

            break;

        case EGoThroughConnectionsGetStatus:

            if ( !IsConnectionActive() )

                {

                // Not accepted - delete and continue to the next.

                iConnections.Remove( iConnectionsIndex );

                }

            else

                {

                // Accepted, go to next one.

                iConnectionsIndex++;

                }

            GoToStateAndComplete( EGoThroughConnections );

            break;

        case ECheckIfNetworkModeIII:

            if ( IsNetworkModeIII() )

                {

                StopConnectionsAndDetachL();

                }

            else

                {

                GoToStateAndComplete( ECheckConnectionCount );

                }

            break;

        case EStopConnectionsAndDetach:

            DetachL();

            break;

        case ECheckConnectionCount:

            if ( !IsConnections() )

                {

                GetAttachModeAndDetachIfRequiredL();

                }

            else 

                {

                ConfirmAllConnectionsTerminationL();

                }

            break;

        case EStopConnectionsAndCheckDetachRequired:

            GetAttachModeAndDetachIfRequiredL();

            break;

        case ECheckDetachRequired:

            if ( IsAttachModeOnDemand() )

                {

                DetachL();

                }

            break;

        case EGetBearerThenNameThenConfirmTermination:

            GetNameThenConfirmTerminationL();

            break;

        case EGetNameThenConfirmTermination:

            ConfirmTerminationL( iConnectionName );

            break;

        case EConfirmAllConnectionsTermination:

            if ( IsConfirmed() )

                {

                StopAllConnectionsAndDetachIfRequiredL();

                }

            break;

        case EDetach:

        case EIdle:

        default:

            break;

        }

    if ( !IsActive() )

        {

        // Operation has been finished.

        iState = EIdle;

        CompleteRequest( KErrNone );

        }

    COUTL_RDEBUG_INT( _L("CCoUtlActive::RunL finished - %d: "), iState )

    }

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

// CCoUtlActive::DoCancel

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

//

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

*   Series 60 Customer / ETel 

*   Series 60  ETel API 

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

void CCoUtlActive::DoCancel()

    {

    COUTL_RDEBUG_INT( _L("CCoUtlActive::DoCancel - %d: "), iState )

    // Operation is canceled - cancel ongoing operation and 

    // complete original request with the KErrCancel error code.

    TInt packetServiceCancel = 0;

    TInt connectionMonitorCancel = 0;

    switch ( iState )

        {

        case ECheckIfNetworkModeIII:

            packetServiceCancel = EPacketGetMSClass;

            break;

        case EGetConnectionCount:

            connectionMonitorCancel = EConnMonGetConnectionCount;

            break;

        case EGoThroughConnectionsGetStatus:

        case EGoThroughConnectionsGetBearer:

        case EGetBearerThenNameThenConfirmTermination:

            connectionMonitorCancel = EConnMonGetIntAttribute;

            break;       

        case ECheckDetachRequired:

            packetServiceCancel = EPacketGetAttachMode;

            break;

        case EGetNameThenConfirmTermination:

            connectionMonitorCancel = EConnMonGetStringAttribute;

            break;

        case EConfirmAllConnectionsTermination:

            if ( iConfirmationQuery )

                {

                iConfirmationQuery->CancelConfirmationQuery();

                delete iConfirmationQuery;

                iConfirmationQuery = NULL;

                delete iConfirmationText;

                iConfirmationText = NULL;

                }

            break;

        case EDetach:

            packetServiceCancel = EPacketDetach;

            break;

        case EIdle:

        case EStarted:

        case ECheckIfAttached:     

        case EStopConnectionsAndDetach:

        case EGoThroughConnections:

        case ECheckConnectionCount:

        case EStopConnectionsAndCheckDetachRequired:

        default:

            break;

        }

    if ( packetServiceCancel && iPacketService.SubSessionHandle() )

        {

        iPacketService.CancelAsyncRequest( packetServiceCancel );

        }

    if ( connectionMonitorCancel && iConnectionMonitor.Handle() )

        {

        iConnectionMonitor.CancelAsyncRequest( connectionMonitorCancel );

        }

    CompleteRequest( KErrCancel );

    GoToState( EIdle );

    COUTL_RDEBUG( _L("CCoUtlActive::DoCancel finished") )

    }

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

// CCoUtlActive::RunError

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

//

TInt CCoUtlActive::RunError( TInt aError )

    {

    COUTL_RDEBUG_INT( _L("CCoUtlActive::RunError - %d: "), aError )

    // Handles exceptions. Either operation has completed with aError code,

    // or then exception has occured while performing RunL when state has

    // been specified.

    // However, RunL has been implemented in such a way that once asynchronous

    // request has been made, then exception is not raised in that RunL.

    switch ( iState )

        {

        case EStopConnectionsAndDetach:

            // Try to move on.

            GoToStateAndComplete( EDetach );

            break;

        case EGoThroughConnectionsGetBearer:

        case EGoThroughConnectionsGetStatus:

            if ( aError == KErrNotFound && 

                ( iConnectionsIndex < iConnections.Count() ) )

                {

                iConnections.Remove( iConnectionsIndex );

                GoToStateAndComplete( EGoThroughConnections );

                break;

                }

            //lint -fallthrough

        case EStarted: 

        case ECheckIfAttached:

        case ECheckIfNetworkModeIII:

        case EGetConnectionCount:

        case EGoThroughConnections:

        case ECheckConnectionCount:

        case EGetBearerThenNameThenConfirmTermination:

        case EGetNameThenConfirmTermination:

        case EConfirmAllConnectionsTermination:

        case EStopConnectionsAndCheckDetachRequired:

        case EDetach:

        case ECheckDetachRequired:

        case EIdle:

        default:

            CompleteRequest( aError );

            GoToState( EIdle );

            break;

        }

    return KErrNone;

    }

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

// CCoUtlActive::GetAttachStatusL

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

//

void CCoUtlActive::GetAttachStatusL()

    {

    TInt status = KErrNone;

    TInt statusWcdma = KErrNone;

    //Fetch attach status from RProperty.

    TInt error = RProperty::Get( KUidSystemCategory, KPSUidGprsStatusValue, status );

    if ( error != KErrNone )

        {

        // On error, assume attached - connection monitor will inform

        // detailed information.

        status = EPSGprsAttach;

        }

    error = RProperty::Get( KUidSystemCategory, KPSUidWcdmaStatusValue, statusWcdma );

    if ( error != KErrNone )

        {

        // On error, assume attached - connection monitor will inform

        // detailed information.

        statusWcdma = EPSWcdmaAttach;

        }

    iServiceStatus = status;

    iWcdmaConnectionStatus = statusWcdma;

    GoToStateAndComplete( ECheckIfAttached );

    }

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

// CCoUtlActive::GetNetworkModeL

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

//

void CCoUtlActive::GetNetworkModeL()

    {

    PacketServiceL().GetMSClass( iStatus, iCurrentClass, iMaxClass );

    SetActive();

    GoToState( ECheckIfNetworkModeIII );

    }

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

// CCoUtlActive::StopConnectionsAndDetachL

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

//

void CCoUtlActive::StopConnectionsAndDetachL()

    {

    TInt err = DoStopAllConnectionsL();

    GoToStateAndComplete( 

        EStopConnectionsAndDetach,

        err );

    }

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

// CCoUtlActive::GetConnectionCountL

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

//

void CCoUtlActive::GetConnectionCountL()

    {

    GoToState( EGetConnectionCount );

    ConnectionMonitorL().GetConnectionCount( iConnectionCount, iStatus );

    SetActive();

    }

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

// CCoUtlActive::CheckConnectionsL

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

//

void CCoUtlActive::CheckConnectionsL()

    {

    RConnectionMonitor& monitor = ConnectionMonitorL();

    iConnections.Reset();

    // Go through all connections

    // Note indexing from 1, 2, 3, .., iConnectionCount.

    for ( TUint index = 1; index <= iConnectionCount; index++ )

        {

        TConnectionId id;

        TUint subConnectionCount = 0;

        TInt err = 

            monitor.GetConnectionInfo( 

                index, 

                id.iConnectionId, 

                subConnectionCount );

        // SubConnectionIds are not used.

        id.iSubConnectionId = 0;

        if ( err != KErrNotFound )

            {

            // the KErrNotFound error code indicates that connection has

            // already been dropped, so those indices are simply ignored.

            User::LeaveIfError( err );

            User::LeaveIfError( iConnections.Append( id ) );

            }

        }

    GoToStateAndComplete( EGoThroughConnections );

    }

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

// CCoUtlActive::GoThroughConnectionsGetBearerL

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

//

void CCoUtlActive::GoThroughConnectionsGetBearerL()

    {

    TConnectionId& current = iConnections[ iConnectionsIndex ];

    ConnectionMonitorL().GetIntAttribute( 

        current.iConnectionId,

        current.iSubConnectionId,

        KBearer,

        iConnectionBearer,