/*

* Copyright (c) 2007 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:    Wrap rconnection*

*/

// INCLUDE FILES

#include "CCRConnection.h"

#include <e32msgqueue.h>

#include <ipvideo/CRTypeDefs.h>

#include "videoserviceutilsLogger.h"

// CONSTANTS

// None.

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

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

// CCRConnection::CCRConnection

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

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

//

CCRConnection::CCRConnection( RSocketServ& aSockServer )

  : CActive( EPriorityStandard ), 

    iSockServer( aSockServer ),

    iState( CCRConnection::EIdle )

    {

    // None

    }

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

// CCRConnection::NewL

// Two-phased constructor.

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

//

CCRConnection* CCRConnection::NewL( RSocketServ& aSockServer )

    {

    CCRConnection* self = new( ELeave ) CCRConnection( aSockServer );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CCRConnection::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CCRConnection::ConstructL()

    {

    CActiveScheduler::Add( this );

    User::LeaveIfError( iConnection.Open( iSockServer ) );

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

    // Request bearer changes events from RConnectionMonitor

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

    }

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

// CCRConnection::~CCRConnection

// Destructor.

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

//

CCRConnection::~CCRConnection()

    {

    LOG( "CCRConnection::~CCRConnection()" );

    if ( iConMonProgressNotifyPending && iConnection.SubSessionHandle() )

        {

        LOG( "~CCRConnection CancelProgressNotification" );

        iConnection.CancelProgressNotification();

        }

    Cancel();

    iConMon.CancelNotifications();

    iConMon.Close();

    CloseRConnection();

    iObservers.Close();

    }

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

// CCRConnection::Start

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

//      

void CCRConnection::Attach( TUint aConnectionId ) 

    {

    LOG1( "CCRConnection::Attach: aConnectionId: %u", aConnectionId );

    Cancel();

    iCurrentConnectionId = aConnectionId;

    iConMon.GetConnectionCount( iConnectionCount, iStatus );

    SetActive();

    iState = CCRConnection::EFindingAP;

    }

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

// CCRConnection::DoCancel

// If we need to cancel.

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

//

void CCRConnection::DoCancel()

    {

    LOG( "CCRConnection::DoCancel" );

    if ( iState == CCRConnection::EFindingAP )

        {

        LOG( "CCRConnection::DoCancel in EFindingAP" );

        iConMon.CancelAsyncRequest( EConnMonGetConnectionCount );

        }

    else if ( iState == CCRConnection::EFindingBearer )

        {

        LOG( "CCRConnection::DoCancel in EFindingBearer" ); 

        iConMon.CancelAsyncRequest( EConnMonGetIntAttribute );

        }

    else if ( iState == CCRConnection::EOpen && iConnection.SubSessionHandle() )

        {

        LOG( "CCRConnection::DoCancel in EOpen" );

        iConMonProgressNotifyPending = EFalse;

        iConnection.CancelProgressNotification();

        }

    else if ( iState == CCRConnection::EConnecting )

        {

        LOG( "CCRConnection::DoCancel in EConnecting" );

        // How to cancel a RConnection::Start?

        }

    LOG( "CCRConnection::DoCancel() out" );

    }

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

// CCRConnection::RunL

// Request succesful completion.

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

//

void CCRConnection::RunL()

    {

    LOG2( "CCRConnection::RunL(), iState: %d, iStatus: %d", 

        ( TInt )iState, iStatus.Int() );

    // Not pending any longer

    iConMonProgressNotifyPending = EFalse;

    // Handle state

    TInt err( KErrNone );   

    if ( iStatus.Int() == KErrNone )

        {

        if (  iState == CCRConnection::EFindingAP )

            {

            err = FindApL();

            }

    	else if ( iState == CCRConnection::EFindingBearer )

            {

            FindBearerL();

            }

        else if ( iState == CCRConnection::EOpen )

            {

            NotificationL();

            }

        }

    else

        {

        SendConnectionErrorToQueue( iStatus.Int() );

        }

    // Verify status

    if ( err )

        {

        LOG1( "CCRConnection::RunL(), err: %d", err );  

        SendConnectionErrorToQueue( err );

        }

    }

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

// CCRConnection::SendConnectionErrorToQueue

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

//

void CCRConnection::SendConnectionErrorToQueue( TInt aError )

    {

    LOG1( "CCRConnection::SendConnectionErrorToQueue() aError: %d", aError );

    iState = CCRConnection::EIdle;

    iCurrentConnectionId = 0;

    iBearerType = EBearerUnknown;

	CloseRConnection();

    MCRConnectionObserver::TCRConnectionStatus status;

    status = MCRConnectionObserver::ECRConnectionError;

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

        {

        iObservers[i]->ConnectionStatusChange( 0, status, aError );

        }

    }

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

// CCRConnection::RunError

// If anything goes wrong.

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

//

TInt CCRConnection::RunError( TInt aError )

    {

    LOG1( "CCRConnection::RunError: aError %d", aError );

    ( void )aError; // Prevent compiler warning

    iState = CCRConnection::EIdle;

    iCurrentConnectionId = 0;

    iBearerType = EBearerUnknown;

    CloseRConnection();

    return KErrNone; 

    }

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

// CCRConnection::CloseRConnection

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

//

void CCRConnection::CloseRConnection()

    {

    LOG( "CCRConnection::CloseRConnection()" );

    if ( iConnection.SubSessionHandle() )

    	{

    	iConnection.Close();

    	}

    }

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

// CCRConnection::Connection

// Returns the connection.

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

//

RConnection& CCRConnection::Connection ( void ) 

    {

    return iConnection; 

    }

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

// CCRConnection::State

// Returns state of connection.

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

//

CCRConnection::TConnectionState CCRConnection::State( void ) const 

    {

    return iState;  

    }

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

// CCRConnection::BearerType

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

//

TConnMonBearerType CCRConnection::BearerType() const

    {

    return iBearerType;

    }

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

// CCRConnection::RegisterObserver

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

//

TInt CCRConnection::RegisterObserver( MCRConnectionObserver* aObserver )

    {

    LOG( "CCRConnection::RegisterObserver" );

    return iObservers.Append( aObserver );

    }

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

// CCRConnection::UnregisterObserver

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

//

TInt CCRConnection::UnregisterObserver( MCRConnectionObserver* aObserver )

    {

    LOG( "CCRConnection::UnregisterObserver" );

    TInt pos = iObservers.Find( aObserver );

    if ( pos < KErrNone ) 

        {

        return pos;

        }

    iObservers.Remove( pos );

    return KErrNone;

    }

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

// CCRConnection::GetHeuristic

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

//

TBool CCRConnection::GetHeuristic( TConnectionHeuristic aHeuristic )

    {

    TInt bit( 1 << ( TInt )aHeuristic );

    return ( TBool )( iHeuristics & bit );

    }

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

// CCRConnection::SetHeuristic

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

//

void CCRConnection::SetHeuristic( TConnectionHeuristic aHeuristic, TBool aValue )

    {

    TInt mask( 1 << ( TInt )aHeuristic );

    if ( aValue )

        {

        iHeuristics |= mask;

        }

    else

        {

        iHeuristics &= ~mask;

        }

    }

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

// CCRConnection::EventL

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

//

void CCRConnection::EventL( const CConnMonEventBase& aEvent )

    {

	// bearer change events

    if( aEvent.EventType()==EConnMonBearerChange && iState==EOpen )

        {

        // IMPORTANT: EConnMonBearerChange event report changes in *some* connection, not

        // necessarly ours and aEvent.ConnectionId() doest *not* contain plain 'connection id',

        // it has 'bearer id'. So make a new bearertype query to make sure it's ours.

        LOG2( "CCRConnection::EventL: bearer changed, id=%d, bearer=%d", 

            aEvent.ConnectionId(), ( ( CConnMonBearerChange* )( &aEvent) )->Bearer() );

        // Cancel ongoing requests

        if ( IsActive() )

            {

            Cancel();

            }

        iState = CCRConnection::EFindingBearer;

        iConMon.GetIntAttribute( iCurrentConnectionId, 0, KBearer,

                                 ( TInt& )iNewBearerType, iStatus );

		SetActive();

        }

    // other unhandled events

    else

        {

        LOG2( "CCRConnection::EventL: unknown event=%d, connection=%d",

                              aEvent.EventType(), aEvent.ConnectionId() );

        }

    }

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

// CCRConnection::IsBearerWLANor3G

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

//

TBool CCRConnection::IsBearerWLANor3G( TConnMonBearerType aBearer )

    {

    return aBearer == EBearerWCDMA    ||  // from CIptvNetworkEngine::IsBearer3GOrWLAN,

           aBearer == EBearerWLAN     ||  // EBearerLAN is returned by emulator

           aBearer == EBearerCDMA2000 ||

           aBearer == EBearerLAN;

    }

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

// CCRConnection::MaximumBandwidth

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

//

TInt CCRConnection::MaximumBandwidth()

    {

    // Determine bandwidth based on bearer or from ConnectionMonitor attributes

    // (KMaximumBitrateDownlink, KGuaranteedBitrateDownlink) when QoS is supported

    TConnMonBearerType bearer = BearerType();

    TInt bandwidth( 0 );

    switch( bearer )

        {

        case EBearerGPRS:

            bandwidth = KCRBandwidthGPRS;

            break;

        case EBearerEdgeGPRS:

            bandwidth = KCRBandwidthEdgeGPRS;

            break;

        case EBearerWCDMA:

            bandwidth = KCRBandwidthWCDMA;

            break;

        case EBearerWLAN:

            bandwidth = KCRBandwidthWLAN;

            break;

        case EBearerLAN:

            bandwidth = KCRBandwidthLAN;

            break;

        default:

            // None

            break;

        }

    return bandwidth;

    }

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

// CCRConnection::FindApL

// Request succesful completion.

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

//

TInt CCRConnection::FindApL()

    {

    CloseRConnection();

    TInt err( iConnection.Open( iSockServer ) );

    if ( err )

        {

        LOG1( "CCRConnection::FindApL(), Open iConnection err: %d", err );

        return err;

        }

    // Connections

    TUint foundConnections( 0 );

    err = iConnection.EnumerateConnections( foundConnections );

    if ( err )

        {

        LOG1( "CCRConnection::FindApL(), EnumerateConnections fail: %d", err );

        return err;

        }

    // Active connection found

    TUint conId( 0 ); // connection id

    TUint subId( 0 ); // subconnection id

    TUint conToUse( 0 );

    for ( TInt i( 1 ); i <= foundConnections && !err; i++ )

        {

        err = iConMon.GetConnectionInfo( i, conId, subId );

        if ( !err && conId == iCurrentConnectionId ) 

            {

            conToUse = i;   

            i = foundConnections + 1; // break from loop

            }

        }

    if ( err )

        {

        LOG1( "CCRConnection::FindApL() GetConnectionInfo loop err: %d", err );

        return err;

        }

    // Connection info

    TPckgBuf<TConnectionInfo> info;

    err = iConnection.GetConnectionInfo( conToUse, info );

    if ( err )

        {

        LOG1( "CCRConnection::FindApL(), GetConnectionInfo 2 fail: %d", err );

        return err;

        }

    // Attach

    err = iConnection.Attach( info, RConnection::EAttachTypeNormal );

    if ( err )

        {

        LOG1( "CCRConnection::FindApL(), Attach failed: %d", err );

        }

    // Bearer type

    iState = CCRConnection::EFindingBearer;

    iBearerType = EBearerUnknown;

    iConMon.GetIntAttribute( 

        iCurrentConnectionId, 0, KBearer, ( TInt& )iNewBearerType, iStatus );

    SetActive();

    return err;

    }

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

// CCRConnection::FindBearerL

// Request succesful completion.

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

//

void CCRConnection::FindBearerL()

    {

    LOG2( "CCRConnection::FindBearerL(), iCurrentConnectionId: %d, iNewBearerType: %d",

        iCurrentConnectionId, iNewBearerType );

    iState = CCRConnection::EOpen;

    TBool was3g( IsBearerWLANor3G( iBearerType ) );

    TBool is3g( IsBearerWLANor3G( iNewBearerType ) );

    TBool genChanged( was3g^is3g );

    TBool justConnected( iBearerType == EBearerUnknown );

    iBearerType = iNewBearerType;

    // Notify if connection has just gone up

    if ( justConnected )

        {

        // Broadcast IapUp&Running for observers

        MCRConnectionObserver::TCRConnectionStatus status;

        status = MCRConnectionObserver::ECRAttachCompleted;

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

            {

            iObservers[i]->ConnectionStatusChange( 0, status, iStatus.Int() );

            }

        }

    // Notify if connection has just gone up or generation changed

    if ( genChanged )

        {

        // Broadcast IapUp&Running for observers

        MCRConnectionObserver::TCRConnectionStatus status;

        status = MCRConnectionObserver::ECRBearerChanged;

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

            {

            iObservers[i]->ConnectionStatusChange( 0, status, iStatus.Int() );

            }

        }

    if ( iConnection.SubSessionHandle() )

        {

        // Request connection progress notifications from RConnection

        iConMonProgressNotifyPending = ETrue;

        iConnection.ProgressNotification( iNotification, iStatus );

        SetActive();    

        }

    }

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

// CCRConnection::NotificationL

// Request succesful completion.

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

//