/*

* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

*

*/

#include <mpxlog.h>

#include <commdb.h>

#include <basched.h>

#include <cmmanagerext.h>

#include <extendedconnpref.h>

#include "vcxconnutilextengineobserver.h"

#include "vcxconnutilengine.h"

// CONSTANTS

_LIT( KCommDBIapId, "IAP\\Id" );

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

// CVcxConnUtilEngine::NewL()

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

//

CVcxConnUtilEngine* CVcxConnUtilEngine::NewL( MConnUtilExtEngineObserver* aObserver )

    {

    CVcxConnUtilEngine* self = CVcxConnUtilEngine::NewLC( aObserver );  

    CleanupStack::Pop( self ); // self;

    return self;

    }

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

// CVcxConnUtilEngine::NewLC()

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

//

CVcxConnUtilEngine* CVcxConnUtilEngine::NewLC( MConnUtilExtEngineObserver* aObserver )

    {

    CVcxConnUtilEngine* self = new (ELeave) CVcxConnUtilEngine();

    CleanupStack::PushL( self );

    self->iObserver = aObserver;

    self->ConstructL();

    return self;

    }

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

// CVcxConnUtilEngine::CVcxNsConnUtilEngine()

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

//

CVcxConnUtilEngine::CVcxConnUtilEngine( ) : 

    CActive( EPriorityStandard ),     

    iConnectionState( EVCxNotConnected )

    {

    CActiveScheduler::Add( this );

    }

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

// CVcxConnUtilEngine::ConstructL()

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

//

void CVcxConnUtilEngine::ConstructL()

    {

    MPX_DEBUG1("vcxconnutil  ## CVcxConnUtilEngine::ConstructL() in");

    iCmManagerExt.OpenL();

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

    User::LeaveIfError( iConnectionMonitor.ConnectL() );    

    User::LeaveIfError( iConnectionMonitor.NotifyEventL( *this ) );

    // get all destination ids

    iCmManagerExt.AllDestinationsL( iDestinationArray );

    MPX_DEBUG1( "vcxconnutil  ## CVcxConnUtilEngine::ConstructL() out" ); 

    }

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

// CVcxConnUtilEngine::~CVcxNsConnUtilEngine()

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

//

CVcxConnUtilEngine::~CVcxConnUtilEngine()

    {

    if( iMobility )

        {

        // make sure observers are not being called

        // after receiving Error() from Cancel()

        iConnectionState = EVCxDisconnecting;

        iMobility->Cancel();

        delete iMobility;

        }

    if( IsActive() )

        {

        Cancel();

        }

    iConnection.Close();

    iSocketServer.Close();

    iCmManagerExt.Close();

    iConnectionMonitor.Close();

    delete iDestinationName;

    iDestinationArray.Close();

    }

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

// CVcxConnUtilEngine::StartToConnect()

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

//

TInt CVcxConnUtilEngine::StartToConnect( TConnPref& aPref, TBool aConnAsync )

    {

    MPX_DEBUG1( "vcxconnutil  ## CVcxConnUtilEngine::StartToConnect with TConnSnapPref in" );

    TInt err( KErrNone );

    if( EVCxConnected == iConnectionState  ||

        EVCxConnecting == iConnectionState )

        {

        return err;

        }

    iConnectionState = EVCxConnecting;  

    err = iConnection.Open( iSocketServer );

    MPX_DEBUG1( "vcxconnutil  ## CVcxConnUtilEngine::StartToConnect connection opened" );

    if( err != KErrNone )

        {

        return err;

        }   

    if( !IsActive() )

        {

        if( aConnAsync )

            {

            MPX_DEBUG1( "vcxconnutil  ## CVcxConnUtilEngine::StartToConnect connecting async" );

            iConnection.Start( aPref, iStatus );

            SetActive();

            TRAP( err, iObserver->WaitL( EVCxPSConnectionStatus ) );

            if( err == KErrNone )

                {

                // save possible error code from async 

                // connection creation

                err = iConnectingResult;

                }

            else if( err == KLeaveExit )

                {

                // app is closing, active scheduler is about to be closed.

                // cancel connection waiting.

                if( IsActive() )

                    {

                    Cancel();

                    }

                }

            }

        else

            {

            MPX_DEBUG1( "vcxconnutil  ## CVcxConnUtilEngine::StartToConnect connecting sync" );

            err = iConnection.Start();

            if( err == KErrNone )

                {

                iConnectionState = EVCxConnected;

                }

            }

        }

    if( iConnectionState != EVCxConnected )

        {

        iIapId = 0;

        }

    MPX_DEBUG2( "vcxconnutil  ## CVcxConnUtilEngine::StartToConnect with TConnSnapPref err: %d  out", err );

    return err;  

    }

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

// CVcxConnUtilEngine::CreateMobility()

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

//

TInt CVcxConnUtilEngine::CreateMobility()

    {

    TInt err( KErrNone );

    if( iMobility )

        {

        iMobility->Cancel();        

        delete iMobility;

        iMobility = 0;

        }

    if( !iMobility  )

        {        

        TRAP( err, iMobility = CActiveCommsMobilityApiExt::NewL( iConnection, *this ) );

        }

    return err;

    }

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

// CVcxConnUtilEngine::Disconnect()

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

//

void  CVcxConnUtilEngine::Disconnect()

    {

    MPX_DEBUG1( "vcxconnutil  ## CVcxConnUtilEngine::Disconnect in");

    if( iConnectionState != EVCxNotConnected )

        { 

        MPX_DEBUG1( "CVcxConnUtilEngine::Disconnect closing connection");

        iConnectionState = EVCxDisconnecting;

        if( iMobility )

            {

            iMobility->Cancel();

            delete iMobility;

            iMobility = NULL;

            }               

        iConnection.Close();

        iConnectionState = EVCxNotConnected;

        }      

    if( IsActive() )

        {

        Cancel();

        }

    MPX_DEBUG1( "vcxconnutil  ## CVcxConnUtilEngine::Disconnect out");

    }

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

// CVcxConnUtilEngine::PreferredCarrierAvailable()

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

//

void CVcxConnUtilEngine::PreferredCarrierAvailable( TAccessPointInfo aOldAPInfo ,

                                                      TAccessPointInfo aNewAPInfo,

                                                      TBool /*aIsUpgrade*/,

                                                      TBool aIsSeamless )

    {

    MPX_DEBUG1( "vcxconnutil  ## CVcxConnUtilEngine::PreferredCarrierAvailable in");

    MPX_DEBUG2( "PreferredCarrierAvailable oldiap: %d", aOldAPInfo.AccessPoint() );

    MPX_DEBUG2( "PreferredCarrierAvailable newiap: %d", aNewAPInfo.AccessPoint() );

    MPX_DEBUG2( "PreferredCarrierAvailable seamless: %d", aIsSeamless );

    if ( !aIsSeamless && 

         aOldAPInfo.AccessPoint() > 0 &&

         aOldAPInfo.AccessPoint() != aNewAPInfo.AccessPoint() )             

        {                

        if( iConnectionState == EVCxRoamingAccepted )

            {

            // in this case we have a roaming ongoing at the

            // but we have not yet received NewCarrierActive

            // so networking has found yet better usable iap.

            // since everyone have allready accepted roaming we

            // can migrate it right away

            MPX_DEBUG1( "CVcxConnUtilEngine::PreferredCarrierAvailable  migrated due EVCxRoamingAccepted state" ); 

            iMobility->MigrateToPreferredCarrier();

            }

        else if( iConnectionState != EVCxRoamingRequest )

            {

            TBool allowRoam( EFalse );

            iConnectionState = EVCxRoamingRequest;

            TRAPD( err, allowRoam = iObserver->RequestIsRoamingAllowedL() );

            // there is a possibility, that client has disconnected during request

            // in that case, do nothing

            if( iConnectionState == EVCxNotConnected )

                {                

                return;

                }

            if( err == KErrNone && allowRoam )

                {

                MPX_DEBUG1( "CVcxConnUtilEngine::PreferredCarrierAvailable migrated" ); 

                iMobility->MigrateToPreferredCarrier();

                iConnectionState = EVCxRoamingAccepted;

                }

            else

                {

                MPX_DEBUG1( "CVcxConnUtilEngine::PreferredCarrierAvailable ignored" );

                iMobility->IgnorePreferredCarrier();

                iConnectionState = EVCxConnected;

                // reset IAP / SNAP info to the pubsub

                TRAPD( err, iObserver->IapChangedL() );

                if( err != KErrNone )

                    {

                    // internal error, let's try to resolve connection

                    iConnectionState = EVCxError;

                    TRAP( err, iObserver->IapChangedL() );                    

                    }

                }

            }

       else

            {

            MPX_DEBUG1( "CVcxConnUtilEngine::PreferredCarrierAvailable Allready roaming" ); 

            }

        }

    MPX_DEBUG1( "vcxconnutil  ## CVcxConnUtilEngine::PreferredCarrierAvailable out" );

    }

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

// CVcxConnUtilEngine::NewCarrierActive()

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

//

void CVcxConnUtilEngine::NewCarrierActive( TAccessPointInfo /*aNewAPInfo*/, TBool aIsSeamless )

    {

    MPX_DEBUG1( "vcxconnutil  ## CVcxConnUtilEngine::NewCarrierActive in");

    if ( aIsSeamless )

        {

        // It is Seamless. E.g. Mobile IP enabled.

        MPX_DEBUG1( "CVcxConnUtilEngine::NewCarrierActive seamless");

        iConnectionState = EVCxConnected;

        }

    else

        {

        MPX_DEBUG1( "CVcxConnUtilEngine::NewCarrierActive accepting new carrier");

        // We accept the new IAP / SNAP.

        iMobility->NewCarrierAccepted();

        iConnectionState = EVCxConnected;

        // change new IAP / SNAP info to the pubsub

        TRAPD( err, iObserver->IapChangedL() );

        if( err != KErrNone )

            {                    

            // internal error, let's try to resolve connection

            iMobility->NewCarrierRejected();

            iConnectionState = EVCxError;

            TRAP( err, iObserver->IapChangedL() ); 

            }

        }

    MPX_DEBUG1( "vcxconnutil  ## CVcxConnUtilEngine::NewCarrierActive out" );

    }

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

// CVcxConnUtilEngine::EventL()

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

//

void CVcxConnUtilEngine::EventL( const CConnMonEventBase &aConnMonEvent )

    {

    TInt eventType = aConnMonEvent.EventType();

    TInt connectionId = aConnMonEvent.ConnectionId();

    // for other events:

    // if not master instance or event does not concern

    // current connection or we are not connected, do not 

    // need to handle events 

    if( !iObserver->IsMaster() || 

        connectionId != iCurrentConnectionId ||

        iConnectionState != EVCxConnected )

        {

        return;

        }

    switch(eventType)

        {               

        case EConnMonConnectionStatusChange:

            {     

            const CConnMonConnectionStatusChange* event = 

                            static_cast<const CConnMonConnectionStatusChange*>( &aConnMonEvent );

            if( event->ConnectionStatus() == KLinkLayerClosed )

                {

                MPX_DEBUG1( "vcxconnutil  ## CVcxConnUtilEngine::EventL: KLinkLayerClosed ");

                iObserver->IapChangedL();

                }                

            }

            break;

        case EConnMonDeleteConnection:

            {

            iObserver->IapChangedL();

            }

            break;

        default:

            break;

        }

    }

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

// CVcxConnUtilEngine::Error()

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

//

void CVcxConnUtilEngine::Error( TInt aError  )

    {

    MPX_DEBUG2( "vcxconnutil  ## CVcxConnUtilEngine::Error %d in", aError );

    if( aError != KErrNone )

        {

        // Error method is also called, when we call Cancel -method for iMobility

        // during disconnecting or during deallocation. Those are not concidered

        // as "errors" in the connection utility, so they do not require any

        // further handling

        if( iConnectionState != EVCxDisconnecting )

            {

            iConnectionState = EVCxError;

            TRAP_IGNORE( iObserver->IapChangedL() ); 

            }

        }

    MPX_DEBUG1( "vcxconnutil  ## CVcxConnUtilEngine::Error out" );

    }

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

// CVcxConnUtilEngine::GetCmmDestinationIdL()

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

//

TUint32 CVcxConnUtilEngine::GetCmmDestinationIdL( CMManager::TSnapPurpose aPurpose )

    {

    TUint32 destinationId( 0 );

    // get default destination id

    TCmDefConnValue defConnection;

    iCmManagerExt.ReadDefConnL( defConnection );

    // if default is setted to be destination, get it's ID         

    if( defConnection.iType == ECmDefConnDestination && 

        aPurpose == CMManager::ESnapPurposeUnknown )

        {

        destinationId = defConnection.iId;

        }

    else if( defConnection.iType == ECmDefConnConnectionMethod ||

             aPurpose != CMManager::ESnapPurposeUnknown )

        {

        // default connection is connection method,

        // search for the destination of it

        RArray<TUint32> destinations;

        CleanupClosePushL( destinations );            

        iCmManagerExt.AllDestinationsL(destinations);

        RCmDestinationExt destination;

        RCmConnectionMethodExt connectionMethod;

        TInt exists( KErrNotFound );

        TInt count = destinations.Count();

        for( TInt i = 0; i < count && exists != KErrNone; i++ )

            {

            destination = iCmManagerExt.DestinationL( destinations[ i ] );

            CleanupClosePushL( destination ); 

            // look for default destination id

            if( aPurpose == CMManager::ESnapPurposeUnknown )

                {

                // check if connection method belongs to destination

                TRAP( exists, 

                  connectionMethod = destination.ConnectionMethodByIDL( 

                                                           defConnection.iId ) );

                if( exists == KErrNone )

                    {

                    connectionMethod.Close();

                    // correct destination found

                    destinationId = destination.Id();                   

                    }                

                }  

            // look for destination id based on purpose

            else

                {

                if( destination.MetadataL( CMManager::ESnapMetadataPurpose ) == 

                                            aPurpose )

                    {

                    // found, save destination id and end search

                    destinationId =  destination.Id();

                    exists = KErrNone;

                    }

                }

            CleanupStack::PopAndDestroy( &destination ); 

            }

        CleanupStack::PopAndDestroy( &destinations );

        }

    return destinationId;

    }

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

// CVcxConnUtilEngine::PrepareConnectionDetailsL()

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

//

TBool CVcxConnUtilEngine::PrepareConnectionDetailsL( TInt aDestinationID )

    {

    MPX_DEBUG1( "vcxconnutil  ## CVcxConnUtilEngine::PrepareConnectionDetailsL in");

    TBool connectionOk( EFalse );

    ResetConnectionInfo();

    if( aDestinationID )

        {

        MPX_DEBUG2( "CVcxConnUtilEngine::PrepareConnectionDetailsL destinationID: %d", aDestinationID);

        iDestinationId = aDestinationID;

        RCmDestinationExt destination = iCmManagerExt.DestinationL( aDestinationID );

        CleanupClosePushL(destination);

        iDestinationName = destination.NameLC();        

        CleanupStack::Pop( iDestinationName );

        MPX_DEBUG2( "CVcxConnUtilEngine::PrepareConnectionDetailsL destination name: %S", iDestinationName);

        TInt cmCount = destination.ConnectionMethodCount();

        MPX_DEBUG2( "CVcxConnUtilEngine::PrepareConnectionDetailsL method count: %d", cmCount);

        if( cmCount )

            {

            connectionOk = ETrue;

            }

        CleanupStack::PopAndDestroy( &destination );

        }

    MPX_DEBUG1( "vcxconnutil  ## CVcxConnUtilEngine::PrepareConnectionDetailsL out");

    return connectionOk;

    }

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

// CVcxConnUtilEngine::IsIapConnected()

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

//

TBool CVcxConnUtilEngine::IsIapConnected( TUint32 aIapId )

    {  

    MPX_DEBUG1( "vcxconnutil  ## CVcxConnUtilEngine::IsIapConnected in");

    TBool connected( EFalse );