/*

* 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:    Class to handle connection creation.*

*/

// INCLUDE FILES

#include <e32cmn.h>

#include <bldvariant.hrh>

#include <commdb.h>            // CMDBSession

#include <commsdattypesv1_1.h> // CCDWAPIPBearerRecord

#include <cmdestination.h>

#include <cdbcols.h>

#include <commdbconnpref.h>

#include <eikbtgrp.h>

#include <connpref.h>

#include <extendedconnpref.h>

#include <mpxlog.h>

#include <ipvideo/vcxconnectionutility.h>

#include <ipvideo/vcxconnutilengineobserver.h>

#include "vcxconnectionutility.hrh"

#include "vcxconnutilimpl.h"

#include "vcxconnutilengine.h"

#include "vcxconnutilpubsub.h"

#include "vcxconnutilwaitsch.h"

// CONSTANTS

_LIT( KConnUtilRoleSema, "__ConnUtillMasterSlaveRoleSwitchSema__ ");

_LIT( KConnUtilConnectionSema, "__ConnUtillConnectionCreateSema__ ");

const TInt KIptvCenRepAPModeAlwaysAsk = 0;

const TInt KConUtilSemaStartupValue = 1;

const TInt KNbrOfNotFoundConnTries = 30;

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

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

// CVcxConnUtilImpl::NewL()

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

//

CVcxConnUtilImpl* CVcxConnUtilImpl::NewL( CVcxConnectionUtility* aUiInterface )

    {

    CVcxConnUtilImpl* self = CVcxConnUtilImpl::NewLC( aUiInterface );  

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

    return self;

    }

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

// CVcxConnUtilImpl::NewLC()

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

//

CVcxConnUtilImpl* CVcxConnUtilImpl::NewLC( CVcxConnectionUtility* aUiInterface )

    {

    CVcxConnUtilImpl* self = new (ELeave) CVcxConnUtilImpl( aUiInterface );

    CleanupStack::PushL( self );

    self->ConstructL( );

    return self;

    }

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

// CVcxConnUtilImpl::ConstructL()

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

//

void CVcxConnUtilImpl::ConstructL( )

    {

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

    iWaitHandler = CVcxConnUtilWaitSch::NewL();

    iObservers.Reset();

    TInt err( KErrNone );

    err = iSemaSwitchRole.CreateGlobal( KConnUtilRoleSema, KConUtilSemaStartupValue );

    if( err == KErrAlreadyExists )

        {

        // semafore exists already, open it

        err = iSemaSwitchRole.OpenGlobal( KConnUtilRoleSema );

        }

    User::LeaveIfError( err );

    err = iSemaCreateConn.CreateGlobal( KConnUtilConnectionSema, KConUtilSemaStartupValue );

    if( err == KErrAlreadyExists )

        {

        // semafore exists already, open it

        err = iSemaCreateConn.OpenGlobal( KConnUtilConnectionSema );

        }

    User::LeaveIfError( err );

    iEngine = CVcxConnUtilEngine::NewL( this );

    iPubsub = CVcxConnUtilPubSub::NewL( this );

    // check and set pubsub -values 

    TInt activeIap( 0 );

    User::LeaveIfError( iPubsub->GetValue( EVCxPSIapId, activeIap ) );

    if( activeIap != 0 )

        {

        // check if there really is connection, if not reinit values

        if( !iEngine->IsIapConnected( activeIap ) )

            {

            // no connection, data integrity has been corrupted at some point

            activeIap = 0;

            }

        }

    if( activeIap == 0 ) 

        {

        MPX_DEBUG1("CVcxConnUtilImpl::ConstructL() no connection yet, initing values");

        User::LeaveIfError( iPubsub->SetValue( EVCxPSMasterExists, 0 ) );

        User::LeaveIfError( iPubsub->SetValue( EVCxPSIapId, 0 ) );

        User::LeaveIfError( iPubsub->SetValue( EVCxPSSnapId, 0 ) );

        User::LeaveIfError( iPubsub->SetValue( 

                                 EVCxPSConnectionStatus, EVCxNotConnected ) );

        User::LeaveIfError( iPubsub->SetValue( EVCxPSNbrConnInstances, 0 ) );        

        }

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

    }

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

// CVcxConnUtilImpl::CVcxNsConnectionUtility()

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

//

CVcxConnUtilImpl::CVcxConnUtilImpl( CVcxConnectionUtility* aUiInterface ) :

iUIInterface( aUiInterface )

    {

    }

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

// CVcxConnUtilImpl::~CVcxConnectionUtility()

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

//

CVcxConnUtilImpl::~CVcxConnUtilImpl()

    {   

    MPX_DEBUG1("vcxconnutil ## CVcxConnUtilImpl::~CVcxConnUtilImpl in");

    iObservers.Close();

    if( iEngine && iPubsub )

        {

        TRAP_IGNORE( DisconnectL() );

        }

    delete iWaitHandler;

    iSemaSwitchRole.Close();

    iSemaCreateConn.Close();

    delete iPubsub;

    delete iEngine;

    MPX_DEBUG1("vcxconnutil ## CVcxConnUtilImpl::~CVcxConnUtilImpl out");

    }

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

// CVcxConnUtilImpl::RegisterObserverL

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

//

void CVcxConnUtilImpl::RegisterObserverL( MConnUtilEngineObserver* aObserver )

   {

   MPX_DEBUG1("vcxconnutil ## CVcxConnUtilImpl::RegisterObserverL in");

   iObservers.AppendL( aObserver );

   MPX_DEBUG1("vcxconnutil ## CVcxConnUtilImpl::RegisterObserverL out");

   }

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

// CVcxConnUtilImpl::RemoveObserver

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

//

void CVcxConnUtilImpl::RemoveObserver( MConnUtilEngineObserver* aObserver )

   {

   MPX_DEBUG1("Cvcxconnutil ## VcxConnUtilImpl::RemoveObserver in");

   TInt i;

   for ( i = 0; i < iObservers.Count(); i++ )

       {

       if ( aObserver == iObservers[i] )

           {

           iObservers.Remove( i );

           iObservers.Compress();

           break;

           }

       } 

   MPX_DEBUG1("Cvcxconnutil ## VcxConnUtilImpl::RemoveObserver out");

   }

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

// CVcxConnUtilImpl::EngineConnectionStatus

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

//

TVCxConnectionStatus CVcxConnUtilImpl::EngineConnectionStatus()

    {

    return iEngine->ConnectionStatus();

    }

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

// CVcxConnUtilImpl::GetIap

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

//

TInt CVcxConnUtilImpl::GetIap( TUint32& aIapId, TBool aSilent )

    {

    MPX_DEBUG1("vcxconnutil ## CVcxConnUtilImpl::GetIap in ");

    aIapId = 0;

    TInt err( KErrNone );

    // assume always new connection

    iNewConnection = ETrue;

    switch ( iEngine->ConnectionStatus() )

        {

        case EVCxNotConnected:            

        case EVCxDisconnecting:                    

            iSemaCreateConn.Wait();

            err = KErrNotFound;

            // KErrNotFound from connection creation indicates that we have 

            // some destination with unusable iap(s) in it for we cannot connect to

            // in that case, destination id to db is setted as "always ask" and connection

            // creation will be tried again for 30 times

            for(TInt i = 0; i < KNbrOfNotFoundConnTries && err == KErrNotFound; ++i)

                {

                err = CreateConnection( aSilent );

                MPX_DEBUG2("vcxconnutil ## CVcxConnUtilImpl::GetIap - CreateConnection returned %d ", err );

                }

            iSemaCreateConn.Signal();    

            break;             

        case EVCxConnecting:

            {

            // this instance is connecting, meaning engine is waiting for

            // networking to create connection, we need to wait for the engine 

            // to finish it's waiting

            TRAP( err, WaitL( EVCxPSConnectionStatus ) );

            if( iEngine->ConnectionStatus() != EVCxConnected )

                {

                // if main active object didn't managed to create connection,

                // return error. This active object does not know the actual

                // error so return KErrGeneral

                err = KErrGeneral;

                }

            else

                {

                err = HandleFinalizeConnection();

                }

            }

            break;

        case EVCxRoamingAccepted: // pass throught

        case EVCxRoamingRequest:  // pass throught

            TRAP( err, WaitL( EVCxPSConnectionStatus ) );

        default:

            iNewConnection = EFalse; 

            break;

        }          

    if( err == KErrNone )

        {   

        // get iap id if any. If this is the first connection for this 

        // instance, iap id will be fetched later on

        aIapId = iEngine->IapId();       

        }

    MPX_DEBUG2("vcxconnutil ## CVcxConnUtilImpl::GetIap out error: %d ", err );

    return err;

    }

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

// CVcxConnUtilImpl::WapIdFromIapIdL

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

//

TUint32 CVcxConnUtilImpl::WapIdFromIapIdL( TUint32 aIapId )

    {

    MPX_DEBUG1("vcxconnutil ## CVcxConnUtilImpl::WapIdFromIapIdL() in ");

    MPX_DEBUG2("vcxconnutil ## CVcxConnUtilImpl::WapIdFromIapIdL() IAP id = %d", aIapId);

    CMDBSession* db = CMDBSession::NewL( CMDBSession::LatestVersion() );

    CleanupStack::PushL( db );

    // WapIpBearer table contains the mapping between wap and iap id's.

    CCDWAPIPBearerRecord* wapBearerRecord = 

        static_cast<CCDWAPIPBearerRecord*>( CCDRecordBase::RecordFactoryL( KCDTIdWAPIPBearerRecord ) );

    CleanupStack::PushL( wapBearerRecord );

    wapBearerRecord->iWAPIAP = aIapId;

    TBool found = wapBearerRecord->FindL( *db );

    if ( !found )

        {

        MPX_DEBUG1("vcxconnutil ## CVcxConnUtilImpl::WapIdFromIapIdL() Record was not found. Leaving with KErrNotFound.");

        User::Leave(KErrNotFound);

        }

    TUint32 wap = static_cast<TUint32>( wapBearerRecord->iWAPAccessPointId );

    CleanupStack::PopAndDestroy( wapBearerRecord );

    CleanupStack::PopAndDestroy( db );

    MPX_DEBUG2("vcxconnutil ## CVcxConnUtilImpl::WapIdFromIapIdL() Matching WAP id = %d", wap);

    MPX_DEBUG1("vcxconnutil ## CVcxConnUtilImpl::WapIdFromIapIdL() out ");

    return wap;

    }

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

// CVcxConnUtilImpl::PrepareConnSettings()

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

//

TInt CVcxConnUtilImpl::PrepareConnSettings()

    {

    MPX_DEBUG1( "vcxconnutil ## CVcxConnUtilImpl::PrepareConnSettings in");  

    TInt err( KErrNone );

    TInt vcDestinationID( 0 );

    if ( !iEngine->QueryConn() )

        {

        TRAP( err, vcDestinationID = 

            iEngine->GetCmmDestinationIdL( CMManager::ESnapPurposeUnknown ) );

        MPX_DEBUG2( "vcxconnutil ## CVcxConnUtilImpl::PrepareConnSettings - destination id %d", vcDestinationID);  

        }

    TBool detailsGotten( EFalse );

    TRAP( err, detailsGotten = iEngine->PrepareConnectionDetailsL( vcDestinationID ) );

    if( err == KErrNone && !detailsGotten )

        {

        // not able to resolve connection details, proceed with always ask

        iEngine->ResetConnectionInfo();

        }

    MPX_DEBUG1( "vcxconnutil ## CVcxConnUtilImpl::PrepareConnSettings out");  

    return err;            

    }

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

// CVcxConnUtilImpl::CreateConnection()

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

//

TInt CVcxConnUtilImpl::CreateConnection( TBool aSilent )

    {

    MPX_DEBUG1( "vcxconnutil ## CVcxConnUtilImpl::CreateConnectionL in");     

    TInt err( KErrNone );

    TInt connStatusPS( EVCxNotConnected );

    err = PrepareConnSettings();

    if( err != KErrNone )

        {

        MPX_DEBUG1( "vcxconnutil ## CVcxConnUtilImpl::CreateConnectionL error getting connsettings out");

        return err;

        }

    err = iPubsub->GetValue( EVCxPSConnectionStatus, connStatusPS );

    if( err != KErrNone )

        {

        MPX_DEBUG1( "vcxconnutil ## CVcxConnUtilImpl::CreateConnectionL error getting PS conn status out");

        return err;

        }

    // if there is already an active connection created by some other  

    // instance, use that one

    TInt snapId( 0 );

    TBool masterConnect( EFalse );

    if( connStatusPS == EVCxConnected || connStatusPS == EVCxRoamingRequest )

        {        

        err = iPubsub->GetValue( EVCxPSSnapId, snapId );

        if( err != KErrNone )

            {

            MPX_DEBUG1( "vcxconnutil ## CVcxConnUtilImpl::CreateConnectionL error getting PS snap id, out");                   

            return err;

            }

        if( snapId == 0 )

            {

            MPX_DEBUG1( "vcxconnutil ## CVcxConnUtilImpl::CreateConnectionL not usable snap is in PS");

            // current snap is undefined, set snap id KErrNotFound for 

            // DoCreateConnection to use active iap instead of snap id

            snapId = KErrNotFound;

            }

        }

    else

        {

        masterConnect = ETrue;

        snapId = iEngine->DestinationId();

        }

    err = DoCreateConnection( aSilent, snapId, masterConnect );

    if( err == KErrNotFound && masterConnect )

        {

        // KErrNotFound from connection creation indicates that we have 

        // some destination with unusable iap(s) in it. Enable connection query.

        MPX_DEBUG1( "vcxconnutil ## CVcxConnUtilImpl::CreateConnectionL - set connection query");

        iEngine->SetQueryConn( ETrue );

        }

    if( err == KErrNone )

        {

        err = HandleFinalizeConnection();

        }

    MPX_DEBUG2( "vcxconnutil ## CVcxConnUtilImpl::CreateConnectionL out (%d)", err);

    return err;

    }

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

// CVcxConnUtilImpl::DoCreateConnection()

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

//

TInt CVcxConnUtilImpl::DoCreateConnection(  TBool /*aSilent*/, TInt32 aSnapId, TBool aMasterConnect )

    {

    MPX_DEBUG2( "vcxconnutil ## CVcxConnUtilImpl::DoCreateConnectionL in (snapId=%d)", aSnapId);

    TInt err( KErrNone );

    if ( aSnapId == KIptvCenRepAPModeAlwaysAsk )

        {  

        //In always ask mode we show always ask dialog

        TCommDbConnPref connPref;

        connPref.SetDialogPreference(  ECommDbDialogPrefPrompt  );

        err = iEngine->StartToConnect( connPref );

        MPX_DEBUG2( "CVcxConnUtilImpl::DoCreateConnectionL connection start always ask err %d", err);

        }

    else if ( aSnapId > KIptvCenRepAPModeAlwaysAsk )

        {

        TConnSnapPref prefs;

        prefs.SetSnap( aSnapId );

        err = iEngine->StartToConnect( prefs, aMasterConnect );

        MPX_DEBUG2( "CVcxConnUtilImpl::DoCreateConnectionL connection start err %d", err);

        }

    else

        {

        TInt iapPS( 0 );

        err = iPubsub->GetValue( EVCxPSIapId, iapPS );

        if( err == KErrNone )

            {

            if( iapPS )

                {

                TCommDbConnPref connPref;

                connPref.SetIapId( iapPS );

                connPref.SetDialogPreference( ECommDbDialogPrefDoNotPrompt );

                err = iEngine->StartToConnect( connPref, EFalse );

                MPX_DEBUG2( "CVcxConnUtilImpl::DoCreateConnectionL connection via iap start err %d", err);

                }

            else

                {

                err = KErrNotFound;

                }            

            }  

        }

    if( err == KErrNone && aMasterConnect )

        {

        err = iEngine->CreateMobility();

        }

    MPX_DEBUG2( "vcxconnutil ## CVcxConnUtilImpl::DoCreateConnectionL out (%d)", err);

    return err;

    }

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

// CVcxConnUtilImpl::HandleFinalizeConnection()

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

//

TInt CVcxConnUtilImpl::HandleFinalizeConnection()

    {

    MPX_DEBUG1( "vcxconnutil ## CVcxConnUtilImpl::HandleFinalizeConnection in");

    if( !iNewConnection )

        {

        // if connection is not new for this instance

        // no finalizing required

        MPX_DEBUG1( "vcxconnutil ## CVcxConnUtilImpl::HandleFinalizeConnection no new connection, out");

        return KErrNone;

        }

    if( iEngine->ConnectionStatus() != EVCxConnected  )

        {

        // connection not ok, no point to proceed, return error

        MPX_DEBUG1( "vcxconnutil ## CVcxConnUtilImpl::HandleFinalizeConnection not connected, out");

        return KErrGeneral;

        }

    iNewConnection = EFalse;

    TRAPD( err, iEngine->FillActiveConnectionDetailsL() );

    if( err == KErrNone )

        {                

        TRAP( err, iPubsub->IncCounterPubSubL( EVCxPSNbrConnInstances ) );              

        if( err == KErrNone )

            {                                    

            // master role check and switch if necessary

            if( !iMaster )

                {

                err = CheckAndChangeSlaveToMaster();                        

                }

            }

            if( err == KErrNone && iMaster )

                {

                TRAP( err, SaveConnectionToPubSubL() );

                }

            if( err == KErrNone )

                {    

                // start getting events from pubsub

                iPubsub->StartSubscibers();

                }

         }            

     if( err != KErrNone )

         {

         // some operation above failed, internal error

         // try to disconnect and return error       

         TRAPD( errDisc, DisconnectL() );

         // return latest error if disconnecting fails

         if( errDisc != KErrNone )

             {

             err = errDisc;

             }

         }

     MPX_DEBUG1( "vcxconnutil ## CVcxConnUtilImpl::HandleFinalizeConnection out");

     return err;