/*

 * Copyright (c) 2005 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:   GPRS and Wlan status getter for sending Generic Alerts

 *

 */

// INCLUDE FILES

//System Includes

#include <startupdomainpskeys.h>	//GlobalRFsStates

#include <rconnmon.h>	//RConnectionMonitor

#include <featmgr.h>	//Feature Manager

#include <features.hrh>	//Feature Manager

#include <cmconnectionmethoddef.h>

#include <cmmanagerext.h>

#include <cmpluginwlandef.h>

#include <cmpluginpacketdatadef.h>

//User Includes

#include "FotaServer.h"

#include "FotaNetworkRegStatus.h"

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

// CFotaNetworkRegStatus::NewL

// Symbian 2-Phase construction, NewL used for creating object of this class

// This method can leave

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

CFotaNetworkRegStatus* CFotaNetworkRegStatus::NewL(CFotaServer* aObserver)

    {

    CFotaNetworkRegStatus* self = CFotaNetworkRegStatus::NewLC(aObserver);

    CleanupStack::Pop(self);

    return self;

    }

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

// CFotaNetworkRegStatus::NewLC

// Symbian 2-Phase construction, NewLC used for creating object of this class

// This method can leave

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

CFotaNetworkRegStatus* CFotaNetworkRegStatus::NewLC(CFotaServer* aObserver)

    {

    CFotaNetworkRegStatus* self = new (ELeave) CFotaNetworkRegStatus(

            aObserver);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// CFotaNetworkRegStatus::ConstructL

// Symbian 2-Phase construction, ConstructL used for constructing the members of this class

// This method can leave

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

void CFotaNetworkRegStatus::ConstructL()

    {

    iTimer.CreateLocal();

    iMonitor.ConnectL();

    }

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

// CFotaNetworkRegStatus::CFotaNetworkRegStatus

// C++ Constructor

// This method shouldn't leave

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

CFotaNetworkRegStatus::CFotaNetworkRegStatus(CFotaServer* aObserver) :

    CActive(CActive::EPriorityStandard), iObserver(aObserver), iRetriesLeft(

            KRetries), iGlobalRFState(EFalse)

    {

    CActiveScheduler::Add(this); // Add AO to current active scheduler

    }

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

// CFotaNetworkRegStatus::~CFotaNetworkRegStatus

// C++ Desctructor

// This method shouldn't leave

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

CFotaNetworkRegStatus::~CFotaNetworkRegStatus()

    {

    Cancel();

    iTimer.Close();

    iMonitor.Close();

    }

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

// CFotaNetworkRegStatus::DoCancel()

// Cancels currently active notifier, if such exists

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

//

void CFotaNetworkRegStatus::DoCancel()

    {

    FLOG(_L("CFotaNetworkRegStatus::DoCancel >>"));

    if (IsActive())

        {

        iTimer.Cancel();

        //		Cancel();

        }

    FLOG(_L("CFotaNetworkRegStatus::DoCancel <<"));

    }

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

// CFotaNetworkRegStatus::StartMonitoringL

// Monitors for connection status

// This method don't leave

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

void CFotaNetworkRegStatus::StartMonitoringL()

    {

    FLOG(_L("CFotaNetworkRegStatus::StartMonitoringL >>"));

    //Check offline state

    FLOG(_L("Check GlobalRF state..."));

    if (!iGlobalRFState)

        {

        iGlobalRFState = CheckGlobalRFState();

        }

    if (iGlobalRFState)

        {

        //Check registration state only if iGlobalRFState is true

        FLOG(_L("Check registration state..."));

        if (CheckNetworkRegStateL())

            {

            //If both are successful report complete

            FLOG(

                    _L("Network Registration is successful, sending Status as success to FotaServer"));

            iObserver->ReportNetworkStatus(ETrue);

            return;

            }

        }

    //If one of them is not successful, start timer and retry KRetries times...

    if (--iRetriesLeft >= 0)

        {

        FLOG(_L("Retry count... [%d]"), KRetries - iRetriesLeft);

        iTimer.After(iStatus, KTimeInterval);

        if (!IsActive())

            SetActive();

        }

    else

        {

        FLOG(

                _L("Maximum retries (%d) reached, sending Status as failure to FotaServer"),

                KRetries);

        iObserver->ReportNetworkStatus(IsWlanSupportedL());

        }

    FLOG(_L("CFotaNetworkRegStatus::StartMonitoringL <<"));

    }

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

// CFotaNetworkRegStatus::RunL()

// Called when event accomplished

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

//

void CFotaNetworkRegStatus::RunL()

    {

    FLOG(_L("CFotaNetworkRegStatus::RunL >>"));

    if (iStatus == KErrNone)

        {

        StartMonitoringL();

        }

    else

        {

        iObserver->ReportNetworkStatus(EFalse);

        }

    FLOG(_L("CFotaNetworkRegStatus::RunL <<"));

    }

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

// CFotaNetworkRegStatus::RunError

// Called when RunL leaves

// This method can't leave

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

TInt CFotaNetworkRegStatus::RunError(TInt aError)

    {

    FLOG(_L("CFotaNetworkRegStatus::RunL >>"));

    iObserver->ReportNetworkStatus(EFalse);

    FLOG(_L("CFotaNetworkRegStatus::RunL <<"));

    return KErrNone;

    }

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

// CFotaNetworkRegStatus::CheckGlobalRFState

// Checks for GlobalRFState, set by Starter

// This method can't leave

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

TBool CFotaNetworkRegStatus::CheckGlobalRFState()

    {

    FLOG(_L("CFotaNetworkRegStatus::CheckGlobalRFState >>"));

    RProperty prop;

    TInt val = KErrNone;

    TInt err = KErrNone;

    TInt status = EFalse;

    err = prop.Get(KPSUidStartup, KPSGlobalSystemState, val);

    if (err == KErrNone && val == ESwStateNormalRfOn)

        {

        //Phone is not offline. Check for Network Registration status

        FLOG(_L("Phone is online. Check for Network Registration status"));

        status = ETrue;

        }

    else

        {

        //Phone is offline. No Network activities allowed.

        FLOG(_L("Phone is offline. No Network activities allowed."));

        status = EFalse;

        }

    FLOG(_L("CFotaNetworkRegStatus::CheckGlobalRFState, status = %d <<"),

            status);

    return status;

    }

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

// CFotaNetworkRegStatus::CheckNetworkRegStatusL

// Checks for Network registration status

// This method can leave

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

TBool CFotaNetworkRegStatus::CheckNetworkRegStateL()

    {

    FLOG(_L("CFotaNetworkRegStatus::CheckNetworkRegStateL >>"));

    TBool status = EFalse;

    TInt registrationStatus(KErrNone);

    TRequestStatus status1;

    iMonitor.GetIntAttribute(EBearerIdGSM, // See bearer ids from TConnMonBearerId

            0, KNetworkRegistration, registrationStatus, status1);

    User::WaitForRequest(status1);

    if (status1.Int() == KErrNone)

        {

        switch (registrationStatus)

            {

            case ENetworkRegistrationHomeNetwork:

            case ENetworkRegistrationRoaming:

                {

                status = ETrue;

                break;

                }

            default:

                {

                /* Includes - 	ENetworkRegistrationNotAvailable:

                 ENetworkRegistrationUnknown:

                 ENetworkRegistrationNoService:

                 ENetworkRegistrationEmergencyOnly:

                 ENetworkRegistrationSearching:

                 ENetworkRegistrationBusy:

                 ENetworkRegistrationDenied:*/

                status = EFalse;

                break;

                }

            }

        }

    FLOG(_L("CFotaNetworkRegStatus::CheckNetworkRegStateL, status = %d <<"),

            status);

    return status;

    }

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

// CFotaNetworkRegStatus::IsWlanSupportedL

// Checks whether Wlan supported on device and active

// This method can leave

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

TBool CFotaNetworkRegStatus::IsWlanSupportedL()

    {

    FLOG(_L("CFotaNetworkRegStatus::IsWlanSupportedL >>"));

    TBool status = EFalse;

    FeatureManager::InitializeLibL();

    if (FeatureManager::FeatureSupported(KFeatureIdProtocolWlan)) // check for feature enabled

        {

        status = ETrue;

        }

    FeatureManager::UnInitializeLib();

#if defined(__WINS__)

    status = ETrue;

#endif

    FLOG(_L("CFotaNetworkRegStatus::IsWlanSupportedL, status = %d <<"),

            status);

    return status;

    }

// End of File