/*

 * 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;

    }

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

// CFotaNetworkRegStatus::IsConnectionPossibleL

// Checks whether the network connection is possible in the given IAP Id

// This method can leave

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

/*TBool CFotaNetworkRegStatus::IsConnectionPossibleL(TInt aIapid)

    {

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

    TBool status(EFalse);

    TUint32 bearer = FindBearerL(aIapid);

    if (bearer == KUidPacketDataBearerType)

        {

        FLOG(_L("Bearer is Packet data"));

        if (CheckGlobalRFState() && CheckNetworkRegStateL())

            {

            FLOG(_L("Network is up and connection is possible "));

            status = ETrue;

            }

        else

            {

            FLOG(_L("Network is not up and connection is not possible "));

            status = EFalse;

            }

        }

    else if (bearer == KUidWlanBearerType)//for wlan or other bearers

        {

        FLOG(_L("Bearer is wlan and proceeding for download "));

        //proceed & this else loop to be removed

        status = ETrue;

        }

    else

        {

        FLOG(_L("Bearer is not packet data or WLAN"));

        }

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

            status);

    return status;

    }*/

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

// CFotaDownload::FindBearerId

// Finds the Bearer Id for a given IAP Id

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

/*TUint32 CFotaNetworkRegStatus::FindBearerL(TInt aIapId)

    {

    FLOG(_L("CFotaNetworkRegStatus::FindBearerL: %d"), aIapId);

    TUint32 bearer = 0;

    TInt err(KErrNone);

    // Query CM Id

    TInt cmId(aIapId);

    RCmManagerExt CmManagerExt;

    TRAP( err, CmManagerExt.OpenL() );

    FLOG(_L("CmManagerExt.OpenL() with error as  %d"), err);

    if (err == KErrNone)

        {

        RCmConnectionMethodExt cm;

        TRAP( err, cm = CmManagerExt.ConnectionMethodL( cmId ) );

        FLOG(_L("CmManagerExt.ConnectionMethodL with error as  %d"), err);

        if (err == KErrNone)

            {

            CleanupClosePushL(cm);

            FLOG(_L("cm pushed to cleanupstack "));

            bearer = cm.GetIntAttributeL(CMManager::ECmBearerType);

            FLOG(_L("bearer is %d "), bearer);

            CleanupStack::PopAndDestroy(); // cm	  

            FLOG(_L("cm poped & destroyed from cleanupstack "));

            }

        CmManagerExt.Close();

        FLOG(_L("CmManagerExt closed "));

        }

    FLOG(_L("CFotaNetworkRegStatus::FindBearerL end with bearer: %d"), bearer);

    return bearer;

    }*/

// End of File