/*

 * Copyright (c) 2009-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:  

 *

 */

#include <networkhandlingproxy.h>

#include <cnwsession.h>

#include <BTSapDomainPSKeys.h>

#include <startupdomainpskeys.h>

#include <PsetContainer.h>

#include <PsetNetwork.h>

#include <PsetSAObserver.h>

#include <centralrepository.h>

#include <CoreApplicationUIsSDKCRKeys.h>

#include "cnetworklistener.h"

#include "mnetworklistenerobserver.h"

#include "networkhandlingstarterlogging.h"

// Constants

// 1-minute timeout before showing soft notification

const TInt KNetworkLostTimeout = 60*1000000;

const TInt KSimRefreshAsynronationTimeout = 1000000;

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

/*!

    Constructor of CNetworkListener.

 */

CNetworkListener::CNetworkListener( MNetworkListenerObserver& aObserver )

    :

    iRegistered(ETrue),

    iObserver(aObserver)

{

    DPRINT << ": IN";

    DPRINT << ": OUT";

}

/*!

    Constructor of CNetworkListener.

 */

void CNetworkListener::ConstructL()

{

    DPRINT << ": IN";

    //Create network handling engine session.

    iSession = CreateL(*this, iInfo);

    iTimer = CPeriodic::NewL(CActive::EPriorityStandard);

    QT_TRYCATCH_LEAVING(iDeviceInfo = new QSystemDeviceInfo())

    iContainer = CPsetContainer::NewL();

    iRefreshHandler = iContainer->CreateRefreshHandlerL();

    iRefreshHandler->NotifyFileChangeL(

            *this,

            KCsp1Ef,

            EFileChangeNotification );

    iSettingsEngine = iContainer->CreateNetworkObjectL(*this);

    DPRINT << ": OUT";

}

/*!

    Constructor of CNetworkListener.

 */

CNetworkListener* CNetworkListener::NewL( MNetworkListenerObserver& aObserver )

{

    DPRINT << ": IN";

    CNetworkListener* self = new(ELeave) CNetworkListener(aObserver);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    DPRINT << ": OUT";

    return self;

 }

/*!

    Destructor of CNetworkListener.

 */

CNetworkListener::~CNetworkListener()

{

    DPRINT << ": IN";

    delete iSession;

    delete iTimer;

    delete iDeviceInfo;

    delete iSettingsEngine;

    delete iRefreshHandler;

    delete iContainer;    

    DPRINT << ": OUT";

}

/*!

    CNetworkListener::HandleNetworkMessage.

 */

void CNetworkListener::HandleNetworkMessage(const TNWMessages aMessage)

{

    DPRINT << ": IN";

    if(aMessage == ENWMessageNetworkRegistrationStatusChange) {

        switch(iInfo.iRegistrationStatus) {

            case ENWNotRegisteredNoService:

                // Fall-through

            case ENWNotRegisteredEmergencyOnly:

                // Fall-through

            case ENWNotRegisteredSearching:

                // Fall-through

            case ENWRegistrationDenied:

                HandleNetworkLost();

                break;

            case ENWRegisteredBusy:

                // Fall-through

            case ENWRegisteredOnHomeNetwork:

                // Fall-through

            case ENWRegisteredRoaming:

                HandleNetworkFound();

                break;

            case ENWRegistrationUnknown:

                // Take no action

            default:

                break;

        }

    }

    DPRINT << ": OUT";

}

/*!

    CNetworkListener::HandleNetworkError.

 */

void CNetworkListener::HandleNetworkError( 

    const TNWOperation /*aOperation*/, TInt /*aErrorCode*/)

    {

    DPRINT << ": IN";

    }

/*!

    CNetworkListener::NWLostDelayCallBack.

 */

TInt CNetworkListener::NWLostDelayCallBack(TAny* aParam)

{

    DPRINT << ": IN";

    CNetworkListener* self = 

        reinterpret_cast< CNetworkListener* >( aParam );

    if ( self ) {

        self->iTimer->Cancel();

        self->iObserver.ShowNote();

    }

    DPRINT << ": OUT";

    return KErrNone;

}

/*!

    CNetworkListener::HandleNetworkFound

 */

void CNetworkListener::HandleNetworkFound()

{

    DPRINT << ": IN";

    if (!iRegistered) {

        iTimer->Cancel();

        iObserver.RemoveNote();

    }

    iRegistered = ETrue;

    DPRINT << ": OUT";

}

/*!

    CNetworkListener::HandleNetworkLost

 */

void CNetworkListener::HandleNetworkLost()

{

    DPRINT << ": IN";

    if (iInfo.iSelectionSetting == ENWNetworkSelectionManual) {

        // See if we were registered before

        if (iRegistered) {

            iRegistered = EFalse;

            if (IsNetworkConnectionAllowed() &&

                !IsBluetoothSAPConnected() &&

                IsSimOk()) {

                // Start 60 second timer and when expired show the

                // notifier

                iTimer->Cancel();

                iTimer->Start(KNetworkLostTimeout,

                              KNetworkLostTimeout,

                              TCallBack( NWLostDelayCallBack, this ));

             }

        }

    }

    DPRINT << ": OUT";

}

/*!

    CNetworkListener::IsNetworkConnectionAllowed

 */

TBool CNetworkListener::IsNetworkConnectionAllowed() const

{

    DPRINT << ": IN";

    // Key indicates whether network connections are allowed.

    // E.g. is Offline Mode active or not.

    TInt nwConnectionAllowed( ECoreAppUIsNetworkConnectionAllowed );

    CRepository* repository = CRepository::NewL( KCRUidCoreApplicationUIs );

    repository->Get(KCoreAppUIsNetworkConnectionAllowed,nwConnectionAllowed);

    delete repository;

    repository = NULL;

    DPRINT << ": OUT, nwConnectionAllowed: " << nwConnectionAllowed;

    return nwConnectionAllowed == ECoreAppUIsNetworkConnectionAllowed;

}

/*!

    CNetworkListener::IsBluetoothSAPConnected

 */

TBool CNetworkListener::IsBluetoothSAPConnected() const

{

    DPRINT << ": IN";

    TInt btSapState( EBTSapNotConnected );

    TInt err = RProperty::Get(KPSUidBluetoothSapConnectionState,

                              KBTSapConnectionState,

                              btSapState );

    DPRINT << ": OUT";

    return btSapState != EBTSapNotConnected && err == KErrNone;

}

/*!

    CNetworkListener::IsSimOk

 */

TBool CNetworkListener::IsSimOk() const

{

    DPRINT << ": IN";

    TInt simState(ESimStatusUninitialized);

    TInt err = RProperty::Get(KPSUidStartup,

                              KPSSimStatus,

                              simState );

    DPRINT << ": OUT";

    return simState == ESimUsable && err == KErrNone;

}

/*!

    CNetworkListener::AllowRefresh

 */

TBool CNetworkListener::AllowRefresh(

                const TSatRefreshType aType,

                const TSatElementaryFiles aFiles )

{

    DPRINT << "aType: " << aType;

    DPRINT << "aFiles: " << aFiles;

    TBool allowRefresh = ETrue;

    if ( iSettingsEngine->IsCallActive() == CPsetSAObserver::EPSetCallActive )

        {

        allowRefresh = EFalse;

        }

    DPRINT << ": OUT allowRefresh " << allowRefresh;

    return allowRefresh;

}

/*!

    CNetworkListener::Refresh

 */

void CNetworkListener::Refresh(

                const TSatRefreshType aType,

                const TSatElementaryFiles aFiles )

{

    DPRINT << ": IN";

    if ((aType != EFileChangeNotification) ||

        ((aType == EFileChangeNotification) &&

        (aFiles & KCsp1Ef)))

        {

        MPsetNetworkSelect::TSelectMode mode;

        iSettingsEngine->GetNetworkSelectMode(mode);

        DPRINT << "mode " << mode;

        if (mode == MPsetNetworkSelect::ENetSelectModeManual) {

            TPSetChangedCspSetting changedCspSettings;

            TPSetChangedCspSetting newValues;

            TInt err = iRefreshHandler->ChangedCspSettings(changedCspSettings, newValues);

            if ((changedCspSettings & EPSetNetSelSup) && 

                !(newValues & EPSetNetSelSup) &&

                (err == KErrNone)) {

                DPRINT << "Network selection not supported ";

                // Network selection mode can't change during SIM refresh,

                // start 1 second timer.

                iTimer->Cancel();

                iTimer->Start(KSimRefreshAsynronationTimeout,

                              KSimRefreshAsynronationTimeout,

                              TCallBack( NWSimRefreshCallBack, this ));

            }

        }

    }

    DPRINT << ": OUT";

}

/*!

    CNetworkListener::HandleNetworkInfoReceivedL

 */

void CNetworkListener::HandleNetworkInfoReceivedL( 

        const CNetworkInfoArray* /*aInfoArray*/, const TInt /*aResult*/ )

{

    DPRINT;

}

/*!

    CNetworkListener::HandleCurrentNetworkInfoL

 */

void CNetworkListener::HandleCurrentNetworkInfoL( 

        const MPsetNetworkSelect::TCurrentNetworkInfo& /*aCurrentInfo*/, 

        const TInt /*aResult*/ )

{

    DPRINT;

}

/*!

    CNetworkListener::HandleNetworkChangedL

 */

void CNetworkListener::HandleNetworkChangedL( 

        const MPsetNetworkSelect::TNetworkInfo& /*aCurrentInfo*/,

        const MPsetNetworkSelect::TCurrentNetworkStatus /*aStatus*/, 

        const TInt /*aResult*/ )

{

    /**

    *  DEPRECATED.

    */

}

/*!

    CNetworkListener::HandleNetworkChangedL

 */

void CNetworkListener::HandleNetworkChangedL( 

        const MPsetNetworkSelect::TNetworkInfo& /*aCurrentInfo*/,

        const RMobilePhone::TMobilePhoneRegistrationStatus& /*aStatus*/, 

        const TInt /*aResult*/ )

{

    DPRINT;

}

/*!

    CNetworkListener::HandleSearchingNetworksL

 */

void CNetworkListener::HandleSearchingNetworksL( TServiceRequest /*aRequest*/ )

{

    DPRINT;

}

/*!

    CNetworkListener::HandleRequestingSelectedNetworkL

 */

void CNetworkListener::HandleRequestingSelectedNetworkL( TBool /*aOngoing*/ )

{

    DPRINT; 

}

/*!

    CNetworkListener::HandleCallActivatedL

 */

void CNetworkListener::HandleCallActivatedL()

{

    DPRINT;

}

/*!

    CNetworkListener::HandleNetworkErrorL

 */

void CNetworkListener::HandleNetworkErrorL( 

        const MPsetNetworkInfoObserver::TServiceRequest /*aRequest*/,

        const TInt /*aError*/ )

{

    DPRINT;

}

/*!

    CNetworkListener::NWSimRefreshCallBack.

 */

TInt CNetworkListener::NWSimRefreshCallBack(TAny* aParam)

{

    DPRINT << ": IN";

    CNetworkListener* self = 

        reinterpret_cast< CNetworkListener* >( aParam );

    if ( self ) {

        self->iTimer->Cancel();

        //Change the network mode to Automatic.

        MPsetNetworkSelect::TNetworkInfo info;

        info.iMode = MPsetNetworkSelect::ENetSelectModeAutomatic;

        DPRINT << ": set network mode to automatic";

        TRAP_IGNORE(self->iSettingsEngine->SelectNetworkL(info));

    }

    DPRINT << ": OUT";

    return KErrNone;

}

// End of file