/*

* Copyright (c) 2002-2010 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:  PSD fax connection information.

*

*/

#include <utf.h>

#include "ConnMonServ.h"

#include "ConnMonIAP.h"

#include "CEventQueue.h"

#include "CPsdFax.h"

#include "log.h"

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

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

// CPsdFax::CPsdFax

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

//

CPsdFax::CPsdFax(

        CConnMonServer* aServer,

        RTelServer* aTelServer,

        RMobilePhone* aMobilePhone,

        RPacketService* aPacketService )

        :

        iServer( aServer ),

        iTelServer( aTelServer ),

        iMobilePhone( aMobilePhone ),

        iPacketService( aPacketService )

    {

    }

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

// CPsdFax::ConstructL

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

//

void CPsdFax::ConstructL()

    {

    //LOGENTRFN("CPsdFax::ConstructL()")

    // Create external connection Up notifier object

    if ( !iConnUpNotifier )

        {

        iConnUpNotifier = new( ELeave ) CPsdFaxUpNotifier(

                this,

                iServer,

                iPacketService );

        // Set object to active scheduler

        iConnUpNotifier->Construct();

        // Start listening events from RConnection

        iConnUpNotifier->Receive();

        }

    //LOGEXITFN("CPsdFax::ConstructL()")

    }

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

// CPsdFax::~CPsdFax

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

//

CPsdFax::~CPsdFax()

    {

    // Delete connection Up notifier object

    if ( iConnUpNotifier )

        {

        iConnUpNotifier->Cancel();

        delete iConnUpNotifier;

        iConnUpNotifier = NULL;

        }

    // Delete all ConnectionData objects

    for ( TUint index = 0; index < KMaxPsdConnectionCount; index++ )

        {

        if ( iConnectionData[index] )

            {

            if ( iConnectionData[index]->IsOpen() )

                {

                iConnectionData[index]->CloseContext();

                }

            delete iConnectionData[index];

            iConnectionData[index] = NULL;

            }

        }

    }

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

// CPsdFax::OpenContext

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

//

TInt CPsdFax::OpenContext( const TUint aIndex, const TDes& aName )

    {

    LOGENTRFN("CPsdFax::OpenContext()")

    TInt err( KErrNone );

    // Create ConnectionData object

    if ( !iConnectionData[aIndex] )

        {

        // Leave left out intentionally, check for NULL instead

        iConnectionData[aIndex] = new CPsdFaxConnectionData( this, iServer, iPacketService ); // No (ELeave)

        if ( !iConnectionData[aIndex] )

            {

            err = KErrNoMemory;

            }

        else

            {

            // Start external connection status notifier

            err = iConnectionData[aIndex]->Construct();

            if ( err != KErrNone )

                {

                // Free allocated resources if failed

                err = KErrNoMemory;

                delete iConnectionData[aIndex];

                iConnectionData[aIndex] = NULL;

                }

            }

        }

    if ( KErrNone == err )

        {

        // Open context to be used in queries

        err = iConnectionData[aIndex]->OpenContext( aName );

        if ( KErrNone == err )

            {

            // Set start time to current time

            iConnectionData[aIndex]->ResetStartTime();

            }

        else

            {

            // Free allocated resources if failed

            delete iConnectionData[aIndex];

            iConnectionData[aIndex] = NULL;

            }

        }

    LOGEXITFN1("CPsdFax::OpenContext()", err)

    return err;

    }

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

// CPsdFax::IsValid

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

//

TBool CPsdFax::IsValid( const TUint aConnectionId )

    {

    LOGENTRFN("CPsdFax::IsValid()")

    TBool result( EFalse );

    TInt index = ConnectionIndex( aConnectionId );

    if ( KErrNotFound != index && iConnectionData[index]->IsOpen() )

        {

        LOGIT("IsValid: connection is valid (open)")

        result = ETrue;

        }

    else if ( !iConnUpNotifier->IsActive() )

        {

        LOGIT("IsValid: connection up notifier is not active -> restart listening")

        iConnUpNotifier->Receive(); // Restart listening

        }

    LOGEXITFN1("CPsdFax::IsValid()", result)

    return result;

    }

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

// CPsdFax::ConnectionIndex

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

//

TInt CPsdFax::ConnectionIndex( const TUint aConnectionId )

    {

    LOGENTRFN("CPsdFax::ConnectionIndex()")

    // Check PSD connection IDs

    for ( TInt index = 0; index < KMaxPsdConnectionCount; index++ )

        {

        if ( iConnectionData[index] )

            {

            // Return connection table index if IDs match

            if ( iConnectionData[index]->ConnectionId() == aConnectionId )

                {

                LOGIT2("CPsdFax::ConnectionIndex() - ConnID %d match, return index %d", aConnectionId, index)

                LOGEXITFN("CPsdFax::ConnectionIndex()")

                return index;

                }

            }

        }

    LOGEXITFN("CPsdFax::ConnectionIndex()")

    return KErrNotFound;

    }

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

// CPsdFax::SetConnectionId

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

//

TInt CPsdFax::SetConnectionId( const TUint aIndex, const TUint aConnectionId )

    {

    LOGENTRFN("CPsdFax::SetConnectionId()")

    TInt err( KErrNone );

    // Check if connection is open

    if ( !iConnectionData[aIndex]->IsOpen() )

        {

        err = KErrNotFound;

        }

    else

        {

        // Set connection ID

        iConnectionData[aIndex]->SetConnectionId( aConnectionId );

        }

    LOGEXITFN1("CPsdFax::SetConnectionId()", err)

    return err;

    }

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

// CPsdFax::GetBearer

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

//

TInt CPsdFax::GetBearer( TInt& aBearer, TBearerInfo& aBearerInfo )

    {

    LOGENTRFN("CPsdFax::GetBearer()")

    TInt err( KErrNone );

    RMobilePhone::TMobilePhoneNetworkMode mode;

    err = iMobilePhone->GetCurrentMode( mode );

    if ( KErrNone == err )

        {

        switch( mode )

            {

            case RMobilePhone::ENetworkModeWcdma:

                aBearer = EBearerExternalWCDMA;

                aBearerInfo.iBearer = iServer->Iap()->HsxpaStatus();

                aBearerInfo.iInternal = EFalse;

                break;

            case RMobilePhone::ENetworkModeCdma2000:

                aBearer = EBearerExternalCDMA2000;

                aBearerInfo.iBearer = EBearerInfoCDMA2000;

                aBearerInfo.iInternal = EFalse;

                break;

            case RMobilePhone::ENetworkModeGsm:

                if ( iServer->Iap()->IsEdgeCell() )

                    {

                    aBearer = EBearerExternalEdgeGPRS;

                    aBearerInfo.iBearer = EBearerInfoEdgeGPRS;

                    aBearerInfo.iInternal = EFalse;

                    }

                else

                    {

                    aBearer = EBearerExternalGPRS;

                    aBearerInfo.iBearer = EBearerInfoGPRS;

                    aBearerInfo.iInternal = EFalse;

                    }

                break;

            default:

                err = KErrUnknown;

                break;

            }

        }

    LOGEXITFN1("CPsdFax::GetBearer()", err)

    return err;

    }

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

// CPsdFax::GetAPN

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

//

TInt CPsdFax::GetApn( const TUint aConnectionId, TDes& aName )

    {

    LOGENTRFN("CPsdFax::GetApn()")

    TInt err( KErrNone );

    TInt bearer( 0 );

    TBearerInfo bearerInfo;

    // Check if connection ID is valid and connection is open

    TInt index = ConnectionIndex( aConnectionId );

    if ( KErrNotFound == index || !iConnectionData[index]->IsOpen() )

        {

        err = KErrNotFound;

        }

    else

        {

        err = GetBearer( bearer, bearerInfo );

        if ( KErrNone == err )

            {

            if ( !( bearer != EBearerExternalCDMA2000 &&

                    ( bearerInfo.iBearer != EBearerInfoCDMA2000 && !bearerInfo.iInternal ) ) )

                {

                err = KErrNotSupported;

                LOGIT("GetApn: bearer == EBearerExternalCDMA2000, returning KErrNotSupported")

                }

            else

                {

                // Get connection APN

                err = iConnectionData[index]->GetApn( aName );

                }

            }

        }

    LOGEXITFN1("CPsdFax::GetApn()", err)

    return err;

    }

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

// CPsdFax::GetProtocolType

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

//

TInt CPsdFax::GetProtocolType( const TUint aConnectionId, TInt& aProtocolType )

    {

    LOGENTRFN("CPsdFax::GetProtocolType()")

    TInt err( KErrNone );

    TInt bearer( 0 );

    TBearerInfo bearerInfo;

    // Check if connection ID is valid and connection is open

    TInt index = ConnectionIndex( aConnectionId );

    if ( KErrNotFound == index || !iConnectionData[index]->IsOpen() )

        {

        err = KErrNotFound;

        }

    else

        {

        err = GetBearer( bearer, bearerInfo );

        if ( KErrNone == err )

            {

            if ( !( bearer != EBearerExternalCDMA2000 &&

                    ( bearerInfo.iBearer != EBearerInfoCDMA2000 && !bearerInfo.iInternal ) ) )

                {

                aProtocolType = EProtocolTypeUnknown;

                LOGIT("GetProtocolType: bearer == EBearerExternalCDMA2000, returning KErrNone")

                }

            else

                {

                // Get connection protocol type

                err = iConnectionData[index]->GetProtocolType( aProtocolType );

                }

            }

        }

    LOGEXITFN1("CPsdFax::GetProtocolType()", err)

    return err;

    }

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

// CPsdFax::GetStatus

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

//

TInt CPsdFax::GetStatus( const TUint aConnectionId, TInt& aStatus )

    {

    LOGENTRFN("CPsdFax::GetStatus()")

    TInt err( KErrNone );

    // Check if connection ID is valid and connection is open

    TInt index = ConnectionIndex( aConnectionId );

    if ( KErrNotFound == index || !iConnectionData[index]->IsOpen() )

        {

        err = KErrNotFound;

        }

    else

        {

        // Get connection status

        err = iConnectionData[index]->GetStatus( aStatus );

        }

    LOGEXITFN1("CPsdFax::GetStatus()", err)

    return err;

    }

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

// CPsdFax::GetDataVolumes

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

//

TInt CPsdFax::GetDataVolumes( const TUint aConnectionId, TUint& aDLVolume, TUint& aULVolume )

    {

    LOGENTRFN("CPsdFax::GetDataVolumes()")

    TInt err( KErrNone );

    TInt index = ConnectionIndex( aConnectionId );

    if ( KErrNotFound == index || !iConnectionData[index]->IsOpen() )

        {

        err = KErrNotFound;

        }

    else

        {

        // Get data volumes

        err = iConnectionData[index]->GetDataVolumes( aDLVolume, aULVolume );

        }

    LOGEXITFN1("CPsdFax::GetDataVolumes()", err)

    return err;

    }

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

// CPsdFax::GetStartTime

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

//

TInt CPsdFax::GetStartTime( const TUint aConnectionId, TTime& aTime )

    {

    LOGENTRFN("CPsdFax::GetStartTime()")

    TInt err( KErrNone );

    // Check if connection ID is valid and connection is open

    TInt index = ConnectionIndex( aConnectionId );

    if ( KErrNotFound == index || !iConnectionData[index]->IsOpen() )

        {

        err = KErrNotFound;

        }

    else

        {

        // Get connection start time

        err = iConnectionData[index]->GetStartTime( aTime );

        }

    LOGEXITFN1("CPsdFax::GetStartTime()", err)

    return err;

    }

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

// CPsdFax::Stop (sync)

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

//

TInt CPsdFax::Stop( const TUint aConnectionId )

    {

    LOGENTRFN("CPsdFax::Stop()")

    TInt err( KErrNone );

    // Check if connection ID is valid and connection is open

    TInt index = ConnectionIndex( aConnectionId );

    if ( index == KErrNotFound || !iConnectionData[index]->IsOpen() )

        {

        LOGIT1("CPsdFax::Stop() connection not found, index %d", index)

        err = KErrNotFound;

        }

    else

        {

        // Stop connection

        err = iConnectionData[index]->Stop();

        }

    LOGEXITFN1("CPsdFax::Stop()", err)

    return err;

    }

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

// CPsdFax::Stop (async)

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

//

TInt CPsdFax::Stop( const TUint aConnectionId, TRequestStatus& aStatus )

    {

    LOGENTRFN("CPsdFax::Stop(TUint, TRequestStatus)")

    TInt err( KErrNone );

    // Check if connection ID is valid and connection is open

    TInt index = ConnectionIndex( aConnectionId );

    if ( index == KErrNotFound || !iConnectionData[index]->IsOpen() )

        {

        LOGIT1("CPsdFax::Stop() connection not found, index %d", index)

        err = KErrNotFound;

        }

    else

        {

        // Stop connection

        iConnectionData[index]->Stop( aStatus );

        }

    LOGEXITFN1("CPsdFax::Stop(TUint, TRequestStatus)", err)

    return err;

    }

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

// CPsdFax::CleanupConnectionInfo

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

//

TInt CPsdFax::CleanupConnectionInfo( const TUint aConnectionId )

    {

    LOGENTRFN("CPsdFax::CleanupConnectionInfo()")

    TInt err( KErrNone );

    TInt index = ConnectionIndex( aConnectionId );

    if ( index != KErrNotFound )

        {

        iConnectionData[index]->CleanupConnectionInfo();

        }

    else

        {

        LOGIT1("CleanupConnectionInfo: connection ID %d not found", aConnectionId)

        err = KErrNotFound;

        }

    LOGEXITFN1("CPsdFax::CleanupConnectionInfo()", err)

    return err;

    }