/*

* Copyright (c) 2005-2007 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:   Provide interface for the client requestin availability class.

*

*/

#include "musavaconnectionmonitor.h"

#include "musavasettingsimp.h"

#include "musavanetworkavailability.h"

#include "musavaobserver.h"

#include "musavaavailability.h"

#include "musavasharedobject.h"

#include "musavaconnectionmonitorobserver.h"

#include "musavasip.h"

#include "muslogger.h"

#include <e32base.h>

#include <sipprofile.h>

#include <mmtsy_names.h>

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

//  Two-phased constructor.

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

//

CMusAvaConnectionMonitor* CMusAvaConnectionMonitor::NewL( 

                                        CMusAvaSharedObject& aSharedObject )

    {

    MUS_LOG( "mus: [MUSAVA]  -> CMusAvaConnectionMonitor::NewL()" )

    CMusAvaConnectionMonitor* self = 

        new( ELeave ) CMusAvaConnectionMonitor( aSharedObject );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    MUS_LOG( "mus: [MUSAVA]  <- CMusAvaConnectionMonitor::NewL()" )

    return self;

    }

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

//  Destructor.

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

//

CMusAvaConnectionMonitor::~CMusAvaConnectionMonitor()

    {

    MUS_LOG( "mus: [MUSAVA]  -> CMusAvaConnectionMonitor::\

        ~CMusAvaConnectionMonitor()" )

    iConnectionMonitorObserver.Reset();

    iConnectionMonitorObserver.Close();

    // Close the monitor when event notifications are no longer required

    iConnectionMonitor.Close();

    MUS_LOG( "mus: [MUSAVA]  <- CMusAvaConnectionMonitor::\

        ~CMusAvaConnectionMonitor()" )

    }

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

//  Constructor function.

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

//

void CMusAvaConnectionMonitor::EventL(const CConnMonEventBase& aConnMonEvent)

    {

    MUS_LOG( "mus: [MUSAVA]  -> CMusAvaConnectionMonitor::EventL()" )

    TUint connectionId = aConnMonEvent.ConnectionId();

    TInt eventType = aConnMonEvent.EventType();

    MUS_LOG1( "Connection ID = %d", connectionId )

    MUS_LOG1( "Event type = %d", eventType )

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

        {

        iConnectionMonitorObserver[i]->EventL( aConnMonEvent );

        }

    MUS_LOG( "mus: [MUSAVA]  <- CMusAvaConnectionMonitor::EventL()" )

    }

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

//  Constructor function.

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

//

CMusAvaConnectionMonitor::CMusAvaConnectionMonitor( 

                                        CMusAvaSharedObject& aSharedObject ):

iSharedObj( &aSharedObject )

    {

    }

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

//  Second phase constructor.

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

//

void CMusAvaConnectionMonitor::ConstructL()

    {

    MUS_LOG( "mus: [MUSAVA]  -> CMusAvaConnectionMonitor::ConstructL()" )

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

    MUS_LOG( "mus: [MUSAVA]  <- CMusAvaConnectionMonitor::ConstructL()" )

    }

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

//

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

void CMusAvaConnectionMonitor::AddAdapterL( 

                                    MMusAvaConnectionMonitorObserver& aAdapter )

    {

    MUS_LOG( "mus: [MUSAVA]  -> CMusAvaConnectionMonitor::\

             AddAdapterL( MMusAvaConnectionMonitorObserver& aAdapter )" )

    iConnectionMonitorObserver.AppendL( &aAdapter );

    MUS_LOG( "mus: [MUSAVA]  <- CMusAvaSip::\

             AddAdapterL( MMusAvaConnectionMonitorObserver& aAdapter )" )

    }

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

// Created connection ID for multimedia sharing is returned

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

//

TUint CMusAvaConnectionMonitor::CreatedConnectionID()

    {

    return iConnectionID;

    }

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

// Connection ID is stored

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

//

void CMusAvaConnectionMonitor::SetConnectionID( TUint aConnectionID )

    {

    iConnectionID = aConnectionID;

    }

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

// Active connection ID for multimedia sharing is returned

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

//

TUint CMusAvaConnectionMonitor::ConnectionIDL()

    {

    MUS_LOG( "mus: [MUSAVA]  -> CMusAvaConnectionMonitor::ConnectionIDL()" )

    TUint iap =  0; //Internet acces point

    TUint sipIap =  0;  //SIP acces point

    TUint count = 0;    //Number of connections

    TUint id = 0;   //Connection ID

    TUint activeIapID = 0;   //Connection ID for active SIP IAP

    TUint subId = 0;    //SubconnectionID

    TUint subCount; //Subconnectioncount

    TRequestStatus status;

    //Fetch number of connections to count

    count = ConnectionCount();

    if ( count == 0 )

        {

        MUS_LOG( "mus: [MUSAVA] Non connections" )

        }

    else

        {

        MUS_LOG1( "mus: [MUSAVA] Fetch number of connections: %d", count )

        //Fetch internet access point to iap

        sipIap =  MultimediaSharingAccessPointID();

        if ( sipIap == 0 )

            {

            MUS_LOG( "mus: [MUSAVA] Non Access Point ID's for app" )

            }

        else

            {

            MUS_LOG1( "mus: [MUSAVA] Internet access point for sip: %d", 

                                                                sipIap )

            TBool goOn = ETrue;

            for ( TUint i = 1; i <= count && goOn; i++ )

                {

                //Fetch connectionId to id

                User::LeaveIfError(iConnectionMonitor.GetConnectionInfo( 

                                                            i, id, subCount ));

                MUS_LOG1( "mus: [MUSAVA] Connection ID = %d", id )

                //Fetch internet access point to iap

                iConnectionMonitor.GetUintAttribute( id, subId, KIAPId, 

                                                iap, status );

                #ifndef UNIT_TESTING

                User::WaitForRequest( status );

                #endif

                MUS_LOG1( "mus: [MUSAVA] Internet access point %d ", iap )

                // when correct Iap found ...

                if( iap == sipIap )

                    {

                    MUS_LOG( "mus: [MUSAVA]  Connection ID found" )

                    activeIapID = id;

                    goOn = EFalse;

                    }

                }

            }

        }

    MUS_LOG( "mus: [MUSAVA]  <- CMusAvaConnectionMonitor::ConnectionIDL()" )

    return activeIapID;

    }

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

//

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

TBool CMusAvaConnectionMonitor::KillPdpContext()

    {

    MUS_LOG( "mus: [MUSAVA]  -> CMusAvaConnectionMonitor::KillPdpContext" )

    TUint connId = 0;

    TUint subConnectionCount = 0;

    TRequestStatus requestStatus;

    TUint count = ConnectionCount();

    TInt ret = 0;

    TBool retval = EFalse;

    for ( TUint i = 1; i <= count && !retval; i++ )

        {

        TInt bearerType = 0;

        iConnectionMonitor.GetIntAttribute( connId,

                                     subConnectionCount,

                                     KBearer,

                                     bearerType,

                                     requestStatus );

        User::WaitForRequest( requestStatus );

        if ( bearerType == EBearerCSD      ||

             bearerType == EBearerHSCSD    ||

             bearerType == EBearerGPRS     ||

             bearerType == EBearerEdgeGPRS ||

             bearerType == EBearerWCDMA    ||

             bearerType == EBearerWcdmaCSD )

            {

            MUS_LOG1( "mus: [MUSAVA] now killing connection whose connId \

                == <%d>", connId )

            ret = iConnectionMonitor.GetConnectionInfo( i, connId, 

                                                    subConnectionCount );

            if ( ret == KErrNone )

                {

                ret = iConnectionMonitor.SetBoolAttribute( connId, 0, 

                                                    KConnectionStop, ETrue );

                if ( ret == KErrNone )

                    {

                    retval = ETrue;

                    }

                }

            }

        }

    MUS_LOG( "mus: [MUSAVA]  <- CMusAvaConnectionMonitor::KillPdpContext" )

    return retval;

    }

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

//

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

void CMusAvaConnectionMonitor::RemoveAdapter( 

                                    MMusAvaConnectionMonitorObserver& aAdapter )

    {

    MUS_LOG( "mus: [MUSAVA]  -> CMusAvaConnectionMonitor::\

             RemoveAdapter( MMusAvaConnectionMonitorObserver& aAdapter )" )

    TInt index = iConnectionMonitorObserver.Find( &aAdapter );

    if( index != KErrNotFound )

        {

        iConnectionMonitorObserver.Remove( index );

        }

    MUS_LOG( "mus: [MUSAVA]  <- CMusAvaSip::\

             RemoveAdapter( MMusAvaConnectionMonitorObserver& aAdapter )" )

    }

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

//

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

void CMusAvaConnectionMonitor::NotifyEventL()

    {

    MUS_LOG( "mus: [MUSAVA]  -> CMusAvaConnectionMonitor::NotifyEventL()" )

    iConnectionMonitor.NotifyEventL( *this );

    MUS_LOG( "mus: [MUSAVA]  <- CMusAvaConnectionMonitor::NotifyEventL()" )

    }

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

//  Active connection count for multimedia sharing is returned

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

//

TUint CMusAvaConnectionMonitor::ConnectionCount()

    {

    MUS_LOG( "mus: [MUSAVA]  -> CMusAvaConnectionMonitor::ConnectionCount()" )

    TUint          count = (TUint) KErrNotFound;

    TRequestStatus status;

    iConnectionMonitor.GetConnectionCount( count, status );

    #ifndef UNIT_TESTING

    User::WaitForRequest( status );

    #endif

    if ( status.Int() != KErrNone )

        {

        MUS_LOG( "mus: [MUSAVA]  Phone doesn't have any active connections" )

        }

    MUS_LOG( "mus: [MUSAVA]  <- CMusAvaConnectionMonitor::ConnectionCount()" )

    return count;

    }

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

// Active Internet Access Point ID for multimedia sharing is returned

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

//

TUint CMusAvaConnectionMonitor::MultimediaSharingAccessPointID()

    {

    MUS_LOG( "mus: [MUSAVA]  -> CMusAvaConnectionMonitor::\

        MultimediaSharingAccessPointID()" )

    TUint retval = KErrNone;

    TBool profileCreated = EFalse;

    TRAPD( err, profileCreated = iSharedObj->MusAvaSip().CreateProfileL() );

    if ( err || !profileCreated )

        {

        retval = (TUint)KErrNotFound;

        }

	else

		{

        CSIPProfile* profile = iSharedObj->MusAvaSip().Profile();

        // Get IAP ID

        MUS_LOG( "mus: [MUSAVA]  Get IAP ID" )

        TInt ret = profile->GetParameter( KSIPAccessPointId, iProfileId );

        if( ret )

            {

            MUS_LOG( "mus: [MUSAVA]  IAP ID is not found" )

            MUS_LOG( "mus: [MUSAVA]  <- CMusAvaConnectionMonitor::\

            MultimediaSharingAccessPointID()" )

            retval = (TUint)ret;

            }

		else

			{

	        MUS_LOG1( "mus: [MUSAVA]     IAP ID = %d", iProfileId )

			retval = iProfileId;

			}        

        }

    MUS_LOG( "mus: [MUSAVA]  <- CMusAvaConnectionMonitor::\

        MultimediaSharingAccessPointID()" )

    return retval;

    }