/*

* 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 "musavaconnectionavailability.h"

#include "musavaavailabilityobserver.h"

#include "musavasettingsimp.h"

#include "musavaobserver.h"

#include "musavaavailability.h"

#include "musavasharedobject.h"

#include "musavaconnectionmonitor.h"

#include "musavanetworkregistrationstatus.h"

#include "musavanetworkmodestatus.h"

#include "musavasip.h"

#include "mussettings.h"

#include "mussettingskeys.h"

#include "muslogger.h"

#include <e32base.h>

#include <rconnmon.h>

#include <e32cmn.h>

#include <etelmm.h>

#include <nifvar.h>

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

// Symbian two-phase constructor

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

//

CMusAvaConnectionAvailability* CMusAvaConnectionAvailability::NewL(

    MMusAvaAvailabilityObserver& aObserver,

    CMusAvaSettingsImp& aSettings  )

    {

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

    CMusAvaConnectionAvailability* self =

        CMusAvaConnectionAvailability::NewLC(

            aObserver, aSettings );

    CleanupStack::Pop( self );

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

    return self;

    }

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

//  Two-phased constructor.

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

//

CMusAvaConnectionAvailability* CMusAvaConnectionAvailability::NewLC(

    MMusAvaAvailabilityObserver& aObserver, 

    CMusAvaSettingsImp& aSettings  )

    {

    MUS_LOG( "mus: [MUSAVA]  -> CMusAvaConnectionAvailability::NewLC()" )

    CMusAvaConnectionAvailability* self =

        new( ELeave ) CMusAvaConnectionAvailability(

            aObserver, aSettings );

    CleanupStack::PushL( self );

    self->ConstructL();

    MUS_LOG( "mus: [MUSAVA]  <- CMusAvaConnectionAvailability::NewLC()" )

    return self;

    }

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

//  Destructor.

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

//

CMusAvaConnectionAvailability::~CMusAvaConnectionAvailability()

    {

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

        ~CMusAvaConnectionAvailability()" )

    if( iSharedObj )

        {

        iSharedObj->DeleteSingleton();

        }

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

        ~CMusAvaConnectionAvailability()" )

    }

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

//  Constructor.

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

//

CMusAvaConnectionAvailability::CMusAvaConnectionAvailability(

    MMusAvaAvailabilityObserver& aObserver, 

    CMusAvaSettingsImp& aSettings  )

    :CMusAvaAvailability( aObserver ),

    iSettings( aSettings )

    {

    }

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

// Symbian 2nd phase constructor can leave.

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

//

void CMusAvaConnectionAvailability::ConstructL()

    {

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

    iSharedObj = CMusAvaSharedObject::GetSingletonL();

    iNetworkRegistrationStatus =  &iSharedObj->MusAvaTelephonyStatus();

    iNetworkModeStatus = &iSharedObj->NetworkModeStatus();

    iConnectionMonitor = &iSharedObj->ConnectionMonitor();

    iNetworkRegistrationStatus->AddAdapterL( *this );

	iNetworkModeStatus->AddAdapterL( *this );

	iConnectionMonitor->AddAdapterL( *this );

	iConnectionMonitor->NotifyEventL();

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

    }

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

// From CMusAvaAvailability.

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

//

void CMusAvaConnectionAvailability::DoExecuteL()

    {

    MUS_LOG( "mus: [MUSAVA]  -> CMusAvaConnectionAvailability::DoExecuteL()" )

	MMusAvaObserver::TAvailabilityStatus status; 

    MUS_LOG( "mus: [MUSAVA]  Check network mode" )

    RMobilePhone::TMobilePhoneNetworkMode networkmode = 

                                        iNetworkModeStatus->PhoneNetworkMode();

        {

            if( iConnectionMonitor->ConnectionCount() > 0)       

                {

                MUS_LOG( "mus: [MUSAVA]  Atlease one packect connection exists " )     

                SetState( NetworkRegistrationAndSettingsL() );  

                }

            else

                {

                MUS_LOG( "mus: [MUSAVA]  No Packet connection exists now." )     

                SetState( MMusAvaObserver::EMusAvaEdgeDtmStatusUnknown );                    

        MUS_LOG( "mus: [MUSAVA] Network not available" )

        SetState( MMusAvaObserver::EMusAvaNetworkType );

    MUS_LOG( "mus: [MUSAVA]  <- CMusAvaConnectionAvailability::DoExecuteL()" )

    }

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

// From CMusAvaAvailability.

// Stops execution.

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

//

void CMusAvaConnectionAvailability::Stop()

    {

    MUS_LOG( "mus: [MUSAVA]  -> CMusAvaConnectionAvailability::Stop()" )

    iNetworkRegistrationStatus->RemoveAdapter( *this );

    iNetworkModeStatus->RemoveAdapter( *this );

    iConnectionMonitor->RemoveAdapter( *this );

    SetState( MMusAvaObserver::EMusAvaStatusNotExecuted );

    MUS_LOG( "mus: [MUSAVA]  <- CMusAvaConnectionAvailability::Stop()" )

    }

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

// From CMusAvaAvailability.

// Returns name of *this* availability module.

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

//

MMusAvaObserver::TAvailabilityName CMusAvaConnectionAvailability::Name()

    {

    return MMusAvaObserver::EMusAvaBearerStatus;

    }

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

// 

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

//

void CMusAvaConnectionAvailability::PhoneNetworkModeStatus(

                            RMobilePhone::TMobilePhoneNetworkMode aStatus )

    {

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

    PhoneNetworkModeStatus()" )

    MUS_LOG1( "mus: [MUSAVA] Mobile Phone Network Status = ", aStatus )

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

    PhoneNetworkModeStatus()" )

    }

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

// CMusAvaConnectionAvailability::NetworkRegistrationStatus

// 

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

//

void CMusAvaConnectionAvailability::NetworkRegistrationStatus(

                    RMobilePhone::TMobilePhoneRegistrationStatus aRegStatus )

    {

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

    MUS_LOG1( "Mobile Phone Network Status = ", aRegStatus )

        {

        }

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

    }

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

// CMusAvaConnectionAvailability::EventL

//

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

//

void CMusAvaConnectionAvailability::EventL(

                                        const CConnMonEventBase& aConnMonEvent)

    {

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

    TInt connectionId = 0;

    TInt event = aConnMonEvent.EventType();

    TUint connId = aConnMonEvent.ConnectionId();

    CMusAvaConnectionMonitor& connectionMonitor = 

                                            iSharedObj->ConnectionMonitor();

    TUint musConnID = connectionMonitor.CreatedConnectionID();

    MUS_LOG1( "mus: [MUSAVA] Current connection ID %d = ", musConnID )

    MUS_LOG1( "mus: [MUSAVA] Event connection ID %d = ", connId )

    switch ( event )

        {

        case EConnMonCreateConnection:

            {

            MUS_LOG( "mus: [MUSAVA] Event type = EConnMonCreateConnection" )

            if( musConnID == 0 )

                {

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

                TRAPD( err, connectionId = 

                                        iConnectionMonitor->ConnectionIDL() );

                if ( err == KErrNotFound )

                    {

                    SetState( MMusAvaObserver::EMusAvaConnectionErr );

                    }

               	else

                }

            break;

            }

        case EConnMonDeleteConnection:

            {

            MUS_LOG( "mus: [MUSAVA] Event type = EConnMonDeleteConnection" )

            if( connId == musConnID )

                {

                SetState( MMusAvaObserver::EMusAvaConnectionErr );

                }

            {

            MUS_LOG( "mus: [MUSAVA] Event type = \

            const CConnMonConnectionStatusChange* connectionStatusChange

                 = (const CConnMonConnectionStatusChange*)(&aConnMonEvent);

            TInt connStatus = connectionStatusChange->ConnectionStatus();

            MUS_LOG1( "mus: [MUSAVA] ConnectionStatus =  %d", connStatus )

            if ( connId == musConnID )

                {

                if( connStatus == KConnectionFailure ||

                    connStatus == KConnectionClosed ||

                    connStatus == KDataTransferTemporarilyBlocked ||

                    connStatus == KLinkLayerClosed ||

                    connStatus == KPsdSuspended ||

                    connStatus == KPsdFinishedDeactivation )

                    {

                    SetState( MMusAvaObserver::EMusAvaConnectionErr );

                    }

                if( connStatus == KConnectionOpen ||

                    connStatus == KLinkLayerOpen )

                    {

                    SetState( NetworkRegistrationAndSettingsL() );

                    }

                }

            break;

            }

            {

            MUS_LOG( "mus: [MUSAVA] Event type = EConnMonNetworkStatusChange" )

            const CConnMonNetworkStatusChange* networkStatusChange

                 = (const CConnMonNetworkStatusChange*)(&aConnMonEvent);

			TInt networkStatus = networkStatusChange->NetworkStatus();

            MUS_LOG1( "mus: [MUSAVA] NetworkStatus =  %d", networkStatus )

            if( connId == EBearerIdWCDMA || connId == EBearerIdWcdmaCSD )

            	{

            	if( EConnMonStatusAttached == networkStatus ||

            	    EConnMonStatusActive == networkStatus )

             	else

            	}

            break;

            }

        case EConnMonNetworkRegistrationChange:

            {

            MUS_LOG( "mus: [MUSAVA] Event type = \

            const CConnMonNetworkRegistrationChange* registrationChange

                 = (const CConnMonNetworkRegistrationChange*)(&aConnMonEvent);

            TInt registrationStatus = registrationChange->RegistrationStatus();

            MUS_LOG1( "mus: [MUSAVA] RegistrationStatus =  %d", 

                    registrationStatus )

                }

            break;

            }

        case EConnMonBearerChange:

            {

            MUS_LOG( "mus: [MUSAVA] Event type = EConnMonBearerChange" )

            MUS_LOG1( "mus: [MUSAVA] Bearer =  %d",connId )

            if( connId == EBearerIdGPRS ||

                connId == EBearerIdWCDMA || 

                connId == EBearerIdWcdmaCSD )

                {

                SetState( NetworkRegistrationAndSettingsL() );

                }

            else

                {

                SetState( MMusAvaObserver::EMusAvaNetworkType );

                }

            break;

            }

        case EConnMonPacketDataAvailable:

            {

            MUS_LOG( "mus: [MUSAVA] EConnMonPacketDataAvailable" )

            /* This is for EDGE /DTM support , This is the only place we can be 

               sure that packet data available along with CS call. Here we have to

               check again for activation settings and based on that availability 

               state has to be set

            */

            MMusAvaObserver::TAvailabilityStatus status

                                                = NetworkRegistrationAndSettingsL();

            SetState( status );            

            break;

            }

        case EConnMonPacketDataUnavailable:

            {

            break;

            }

        case EConnMonBearerInfoChange:

            {

            MUS_LOG( "mus: [MUSAVA] EConnMonBearerInfoChange" )           

            break;

            }

        default :

            {

            MUS_LOG( "mus: [MUSAVA] Event type is not implemented" )

            MUS_LOG1( "mus: [MUSAVA] Event type %d = ", event )

            break;

            }

        }

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

    }

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

// CMusAvaConnectionAvailability::MusAvaManualActivation

//

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

//    

MMusAvaObserver::TAvailabilityStatus CMusAvaConnectionAvailability::

    ManualActivationL()

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

    	{

    	MUS_LOG( "mus: [MUSAVA] Operator Specific No Manual query" )

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

    	return MMusAvaObserver::EMusActivationError;	

    	}