/*

* Copyright (c) 2006-2008 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:  Dataport specific network resource accessor implementation

*

*/

#include <mmtsy_names.h>

#include "DunNetDataport.h"

#include "DunUtils.h"

#include "DunDebug.h"

_LIT(DUN_GGP_DATAPORT_CSY_PORT, "::DUN");

_LIT(DUN_GGP_DATAPORT_CSY, "DATAPORT");

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

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

// Two-phased constructor.

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

//

CDunNetDataport* CDunNetDataport::NewL( TInt aNumOfMaxChannels )

    {

    CDunNetDataport* self = new (ELeave) CDunNetDataport( aNumOfMaxChannels );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor.

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

//

CDunNetDataport::~CDunNetDataport()

    {

    FTRACE(FPrint(_L( "CDunNetDataport::~CDunNetDataport()")));

    TInt i;

    TInt count = iEntities.Count();

    for ( i=0; i<count; i++ )

        {

        DeleteNetworkEntity( i, ETrue );

        }

    DeleteNetwork();

    FTRACE(FPrint(_L( "CDunNetDataport::~CDunNetDataport() complete")));

    }

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

// From class MDunNetwork (MDunNetDataport -> MDunNetwork).

// Initializes network for Dataport

// Must be called before any other operation

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

//

void CDunNetDataport::InitializeL()

    {

    FTRACE(FPrint(_L( "CDunNetDataport::InitializeL()")));

    AllocatePhoneObjectsL();

    FTRACE(FPrint(_L( "CDunNetDataport::InitializeL() complete")));

    }

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

// From class MDunNetDataport.

// Called when channel was created by transporter for Dataport

// Initializes network for channel creation

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

//

TInt CDunNetDataport::AllocateChannel( RComm*& aComm )

    {

    FTRACE(FPrint(_L( "CDunNetDataport::AllocateChannel()")));

    TInt firstFree = InitializeFirstFreeEntity();

    if ( firstFree < 0 )

        {

        FTRACE(FPrint(_L( "CDunNetDataport::AllocateChannel() (not found) complete")));

        return firstFree;

        }

    if ( firstFree >= iEntities.Count() )

        {

        FTRACE(FPrint(_L( "CDunNetDataport::AllocateChannel() (firstfree failed!) complete")));

        return KErrGeneral;

        }

    TInt retTemp = iEntities[firstFree].iMobileCall.OpenNewCall( iMobileLine );

    if ( retTemp != KErrNone )

        {

        RemoveEntity( firstFree );  // remove unused initialized channel

        FTRACE(FPrint(_L( "CDunNetDataport::AllocateChannel() OpenNewCall FAILED %d" ), retTemp));

        return KErrGeneral;

        }

    retTemp = iEntities[firstFree].iMobileCall.Connect();

    if ( retTemp != KErrNone )

        {

        RemoveEntity( firstFree );  // remove unused initialized channel

        FTRACE(FPrint(_L( "CDunNetDataport::AllocateChannel() iEntities[%d]->iMobileCall.Connect FAILED %d" ), firstFree, retTemp));

        return KErrGeneral;

        }

    RCall::TCommPort portName;

    portName.iPort.Copy( DUN_GGP_DATAPORT_CSY );

    portName.iPort.Append( DUN_GGP_DATAPORT_CSY_PORT );

    retTemp = iEntities[firstFree].iMobileCall.LoanDataPort( portName );

    if ( retTemp != KErrNone )

        {

        RemoveEntity( firstFree );  // remove unused initialized channel

        if ( retTemp == KErrEtelPortNotLoanedToClient )

            {

            FTRACE(FPrint(_L( "CDunNetDataport::AllocateChannel() (too big) complete")));

            return KErrTooBig;

            }

        FTRACE(FPrint(_L( "CDunNetDataport::AllocateChannel() iEntities[%d]->iMobileCall.LoanDataPort FAILED %d" ), firstFree, retTemp));

        return KErrGeneral;

        }

    FTRACE(FPrint(_L( "CDunNetDataport::AllocateChannel() Created call object at index %d" ), firstFree));

    retTemp = iEntities[firstFree].iDataport.Open( iCommServer,

                                                   portName.iPort,

                                                   ECommExclusive,

                                                   ECommRoleDTE );

    if ( retTemp != KErrNone )

        {

        RemoveEntity( firstFree );  // remove unused initialized channel

        FTRACE(FPrint(_L( "CDunNetDataport::AllocateChannel() FAILED to open dataport %d"), retTemp));

        return KErrGeneral;

        }

    iEntities[firstFree].iDataport.ResetBuffers();

    iEntities[firstFree].iEntityInUse = ETrue;

    aComm = &iEntities[firstFree].iDataport;

    FTRACE(FPrint(_L( "CDunNetDataport::AllocateChannel() (iEntities[%d]->iDataport) opened"), firstFree));

    FTRACE(FPrint(_L( "CDunNetDataport::AllocateChannel() complete")));

    return KErrNone;

    }

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

// From class MDunNetDataport.

// Called when channel was deleted/closed by transporter for Dataport

// Uninitializes network for channel deletion/close

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

//

TInt CDunNetDataport::FreeChannel( RComm* aComm )

    {

    FTRACE(FPrint(_L( "CDunNetDataport::FreeChannel()")));

    TInt i;

    TInt count = iEntities.Count();

    for ( i=0; i<count; i++ )

        {

        if ( &iEntities[i].iDataport == aComm )

            {

            if ( iEntities[i].iEntityInUse )

                {

                break;

                }

            }

        }

    if ( i >= count )

        {

        FTRACE(FPrint(_L( "CDunNetDataport::FreeChannel() (not found) complete")));

        return KErrNotFound;

        }

    DeleteNetworkEntity( i, ETrue );

    FTRACE(FPrint(_L( "CDunNetDataport::FreeChannel() (iEntities[%d]->iDataport) freed"), i));

    FTRACE(FPrint(_L( "CDunNetDataport::FreeChannel() complete")));

    return KErrNone;

    }

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

// From class MDunNetDataport.

// Gets index by network ID for Dataport

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

//

TInt CDunNetDataport::GetIndexById( RComm* aComm )

    {

    FTRACE(FPrint(_L( "CDunNetDataport::GetIndexById()")));

    TInt i;

    TInt count = iEntities.Count();

    for ( i=0; i<count; i++ )

        {

        TDunDataportEntity& entity = iEntities[i];

        if ( entity.iEntityInUse )

            {

            if ( &entity.iDataport == aComm )

                {

                return i;

                }

            }

        }

    FTRACE(FPrint(_L( "CDunNetDataport::GetIndexById() (not found) complete")));

    return KErrNotFound;

    }

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

// CDunNetDataport::CDunNetDataport

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

//

CDunNetDataport::CDunNetDataport( TInt aNumOfMaxChannels ) :

    iNumOfMaxChannels( aNumOfMaxChannels )

    {

    }

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

// CDunNetDataport::ConstructL

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

//

void CDunNetDataport::ConstructL()

    {

    FTRACE(FPrint(_L( "CDunNetDataport::ConstructL()")));

    if ( iNumOfMaxChannels < 0 )

        {

        User::Leave( KErrGeneral );

        }

    TInt retTemp = CDunUtils::ConnectCommsServer( iCommServer );

    if ( retTemp != KErrNone )

        {

        FTRACE(FPrint(_L( "CDunNetDataport::ConstructL() FAILED to connect comms server")));

        User::Leave( retTemp );

        }

    retTemp = iCommServer.LoadCommModule( DUN_GGP_DATAPORT_CSY );

    if ( retTemp != KErrNone )

        {

        iCommServer.Close();

        FTRACE(FPrint(_L( "CDunNetDataport::ConstructL() FAILED to load comm module")));

        User::Leave( retTemp );

        }

    FTRACE(FPrint(_L( "CDunNetDataport::ConstructL() complete")));

    }

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

// Allocates phone objects for use

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

//

void CDunNetDataport::AllocatePhoneObjectsL()

    {

    FTRACE(FPrint(_L( "CDunNetDataport::AllocatePhoneObjectsL()" ) ));

    TInt retTemp;

    retTemp = iTelServer.Connect();

    if ( retTemp != KErrNone )

        {

        FTRACE(FPrint(_L( "CDunNetDataport::AllocatePhoneObjectsL() iTelServer Connect FAILED %d" ), retTemp ));

        User::Leave( retTemp );

        }

    retTemp = iTelServer.LoadPhoneModule( KMmTsyModuleName );

    if ( retTemp!=KErrNone && retTemp!=KErrAlreadyExists )

        {

        FTRACE(FPrint(_L( "CDunNetDataport::AllocatePhoneObjectsL() LoadPhoneModule FAILED %d" ), retTemp ));

        User::Leave( retTemp );

        }

    retTemp = iMobilePhone.Open( iTelServer, KMmTsyPhoneName );

    if ( retTemp != KErrNone )

        {

        FTRACE(FPrint(_L( "CDunNetDataport::AllocatePhoneObjectsL() MobilePhone Open FAILED %d" ), retTemp ));

        User::Leave( retTemp );

        }

    retTemp = iMobileLine.Open( iMobilePhone, KMmTsyDataLineName );

    if ( retTemp != KErrNone )

        {

        FTRACE(FPrint(_L( "CDunNetDataport::AllocatePhoneObjectsL() MobileLine Open FAILED %d" ), retTemp ));

        User::Leave( retTemp );

        }

    FTRACE(FPrint(_L( "CDunNetDataport::AllocatePhoneObjectsL() complete" ) ));

    }

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

// Initializes first free entity

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

//

TInt CDunNetDataport::InitializeFirstFreeEntity()

    {

    FTRACE(FPrint(_L( "CDunNetDataport::InitializeFirstFreeEntity()")));

    TInt i;

    TInt retTemp;

    TInt count = iEntities.Count();

    for ( i=0; i<count; i++ )

        {

        if ( !iEntities[i].iEntityInUse )

            {

            FTRACE(FPrint( _L("CDunNetDataport::InitializeFirstFreeEntity() complete" )));

            return i;

            }

        }

    // Free channel not found, now create new if possible

    if ( iNumOfMaxChannels!=0 && iEntities.Count()>=iNumOfMaxChannels )

        {

        FTRACE(FPrint( _L("CDunNetDataport::InitializeFirstFreeEntity() (too big) complete" )));

        return KErrTooBig;

        }

    TDunDataportEntity emptyEntity;

    emptyEntity.iEntityInUse = EFalse;

    retTemp = iEntities.Append( emptyEntity );

    if ( retTemp != KErrNone )

        {

        FTRACE(FPrint( _L("CDunNetDataport::InitializeFirstFreeEntity() (append failed!) complete" )));

        return retTemp;

        }

    FTRACE(FPrint(_L( "CDunNetDataport::InitializeFirstFreeEntity() complete")));

    return i;

    }

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

// Remove network entity by index

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

//

TInt CDunNetDataport::RemoveEntity( TInt aIndex )

    {

    FTRACE(FPrint(_L( "CDunNetDataport::RemoveEntity()")));

    if ( aIndex < 0 ||

         aIndex >= iEntities.Count() )

        {

        FTRACE(FPrint(_L( "CDunNetDataport::RemoveEntity() (not found) complete")));

        return KErrNotFound;

        }

    DeleteNetworkEntity( aIndex, EFalse );

    FTRACE(FPrint(_L( "CDunNetDataport::RemoveEntity() complete")));

    return KErrNone;

    }

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

// Deletes own internal data

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

//

void CDunNetDataport::DeleteNetwork()

    {

    FTRACE(FPrint(_L( "CDunNetDataport::DeleteNetwork()")));

    if ( iMobileLine.SubSessionHandle() )

        {

        iMobileLine.Close();

        FTRACE(FPrint(_L( "CDunNetDataport::DeleteNetwork() mobile line closed")));

        }

    if ( iMobilePhone.SubSessionHandle() )

        {

        iMobilePhone.Close();

        FTRACE(FPrint(_L( "CDunNetDataport::DeleteNetwork() mobile phone closed")));

        }

    if ( iTelServer.Handle() )

        {

        iTelServer.UnloadPhoneModule( KMmTsyModuleName );

        FTRACE(FPrint(_L( "CDunNetDataport::DeleteNetwork() phone module unloaded")));

        iTelServer.Close();

        FTRACE(FPrint(_L( "CDunNetDataport::DeleteNetwork() phone module closed")));

        }

    if ( iCommServer.Handle() )

        {

        iCommServer.UnloadCommModule( DUN_GGP_DATAPORT_CSY );

        FTRACE(FPrint(_L( "CDunNetDataport::DeleteNetwork() comm module unloaded")));

        iCommServer.Close();

        FTRACE(FPrint(_L( "CDunNetDataport::DeleteNetwork() comm module closed")));

        }

    iEntities.Close();

    FTRACE(FPrint(_L( "CDunNetDataport::DeleteNetwork() complete")));

    }

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

// Deletes one network entity at index aIndex for Dataport

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

//

TInt CDunNetDataport::DeleteNetworkEntity( TInt aIndex, TBool aCheckFree )

    {

    FTRACE(FPrint(_L( "CDunNetDataport::DeleteNetworkEntity()")));

    if ( aIndex < 0 ||

         aIndex >= iEntities.Count() )

        {

        FTRACE(FPrint(_L( "CDunNetDataport::DeleteNetworkEntity() (not found) complete"), aIndex));

        return KErrGeneral;

        }

    TDunDataportEntity& entity = iEntities[aIndex];

    if ( (aCheckFree&&entity.iEntityInUse) || !aCheckFree )

        {

        if ( entity.iDataport.SubSessionHandle() )

            {

            // The next will set KSignalDTEOutputs down twice for RComm

            // local media case because CDunSignalCopy clears them also which

            // in turn causes plugin to free channel. But this probably won't

            // cause any harm.

            entity.iDataport.SetSignals( 0, KSignalDTEOutputs );

            FTRACE(FPrint(_L( "CDunNetDataport::DeleteNetworkEntity() RComm signals set")));

            entity.iDataport.Close();

            FTRACE(FPrint(_L( "CDunNetDataport::DeleteNetworkEntity() RComm closed")));

            }

        if ( entity.iMobileCall.SubSessionHandle() )

            {

            entity.iMobileCall.RecoverDataPort();

            FTRACE(FPrint(_L( "CDunNetDataport::DeleteNetworkEntity() Dataport recovered")));

            entity.iMobileCall.Close();

            FTRACE(FPrint(_L( "CDunNetDataport::DeleteNetworkEntity() Dataport closed")));

            }

        entity.iEntityInUse = EFalse;

        }

    FTRACE(FPrint(_L( "CDunNetDataport::DeleteNetworkEntity() complete")));

    return KErrNone;

    }