/*

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

 *

 */

// USER INCLUDES

#include "DMNetworkMon.h"

#include <SyncMLClient.h>

#include <SyncMLClientDM.h>

#include <nsmldmauthinfo.h>

#include <nsmlconstants.h>

#include <AknGlobalNote.h>

#include <e32const.h>

#include <DevManInternalCRKeys.h>

#include "OnlineSupportLogger.h"

// CONSTANTS

const TInt KGlobalTimeout = 30; // In minutes

//const TInt KNsmlDMNetMonTimeoutKey = 13; // 0x0000013 defined in DM cenrep

const TInt KMicroSecond = 1000000;

const TInt KTimeUnit = 60;

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

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

// CDMNetworkMon::NewL

// Two Phase Construction

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

CDMNetworkMon* CDMNetworkMon::NewL()

    {

    LOGSTRING("CDMNetworkMon::NewL() begins");

    CDMNetworkMon* self = new (ELeave) CDMNetworkMon;

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    LOGSTRING("CDMNetworkMon::NewL() ends");

    return self;

    }

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

// CDMNetworkMon::CDMNetworkMon

// Constructor

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

CDMNetworkMon::CDMNetworkMon() : CActive(CActive::EPriorityHigh)

    {

    LOGSTRING("CDMNetworkMon::CDMNetworkMon() begins");

    CActiveScheduler::Add(this);

    LOGSTRING("CDMNetworkMon::CDMNetworkMon() ends");

    }

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

// CDMNetworkMon::ConstructL

// Second phase constructor

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

void CDMNetworkMon::ConstructL()

    {     

    LOGSTRING("CDMNetworkMon::ConstructL() begins");

    iSyncSessionOpen = EFalse;

    iCancelledNWEvent = EFalse;

    // Initial state

    iPrevState = ERegister;

    iState = ERegister;

    IssueRequest();

    iError = KErrNone;

    iGlobalTimer = CPeriodic::NewL (EPriorityNormal) ;

    iGlobalTimeout = ReadTimeoutFromCenrepL();

    TInt timeout = KGlobalTimeout * KTimeUnit * KMicroSecond;

    iGlobalTimer->Start ( TTimeIntervalMicroSeconds32(timeout), 

            TTimeIntervalMicroSeconds32(timeout), 

            TCallBack(Timeout, this ) );		

    LOGSTRING("CDMNetworkMon::ConstructL() ends");	

    }

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

// CDMNetworkMon::~CDMNetworkMon

// Destructor*

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

CDMNetworkMon::~CDMNetworkMon()

    {

    LOGSTRING("CDMNetworkMon::~CDMNetworkMon() begins");

    if(!iCancelledNWEvent)

    {

    // Un-register for events

    iConnectionMonitor.CancelNotifications();

    iConnectionMonitor.Close();

    }

    // Cleanup sync session

    CloseSyncSession();

    LOGSTRING("CDMNetworkMon::~CDMNetworkMon() ends");

    }

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

// CDMNetworkMon::RunL

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

void CDMNetworkMon::RunL()

    {

    switch ( iState ) 

        {

        case ERegister:

            LOGSTRING("CDMNetworkMon::RunL() State = ERegister");

            RegisterL();

            break;

            // Monitor the operation

        case EMonitor:

            LOGSTRING("CDMNetworkMon::RunL() State = EMonitor");

            StartOperationL();				 

            break;

        case ENetworkUp:

            LOGSTRING("CDMNetworkMon::RunL() State = ENetworkUp");  

            NetworkUp(this);          

            break;

        case EDMJobOk:

            LOGSTRING("CDMNetworkMon::RunL() State = EDMJobOk");

            StartDeviceManagementSessionL();

            break; 

        case EComplete:

            LOGSTRING("CDMNetworkMon::RunL() State = EComplete");

            Complete();

            break;

        default:

            break;

        }

    }

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

// CDMNetworkMon::RunError

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

TInt CDMNetworkMon::RunError ( TInt aError )

    {

    DBG_FILE_CODE(aError, _S8("CDMNetworkMon::RunError() The Error occurred is "));

    return aError;

    }

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

// CDMNetworkMon::DoCancel

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

void CDMNetworkMon::DoCancel()

    {

    LOGSTRING("CDMNetworkMon::DoCancel() begins");

    iCancelledNWEvent = ETrue;

    // Un-register for events

    iConnectionMonitor.CancelNotifications();

    iConnectionMonitor.Close();

    // Cleanup sync session

    CloseSyncSession();

    LOGSTRING("CDMNetworkMon::DoCancel() ends");

    }

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

// CDMNetworkMon::RegisterL

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

void CDMNetworkMon::RegisterL()

    {

    LOGSTRING("CDMNetworkMon::RegisterL() begins");

    // Register for events

    iConnectionMonitor.ConnectL();

#ifndef __WINS__

    iConnectionMonitor.NotifyEventL(*this);  

#endif

    TInt err = iConnectionMonitor.SetUintAttribute( EBearerIdAll, 

            0, 

            KSignalStrengthThreshold, 

            1 );

    // Wait for events

    iState = EMonitor;

    IssueRequest();

    LOGSTRING("CDMNetworkMon::RegisterL() ends");

    }

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

// CDMNetworkMon::PacketDataAvailable

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

TBool CDMNetworkMon::PacketDataAvailable()

    {

    LOGSTRING("CDMNetworkMon::PacketDataAvailable() begins");

    TRequestStatus status;

    TBool val = EFalse;     

    if( iConMonBearerId != TConnMonBearerId(-1))

        {

        iConnectionMonitor.GetBoolAttribute(iConMonBearerId, 

                0,

                KPacketDataAvailability, 

                val,

                status );

        User::WaitForRequest(status);			

        }

    else

        {

        LOGSTRING("CDMNetworkMon::PacketDataAvailable() Invalid connection ID encountered");

        TRequestStatus gprsstatus;

        iConnectionMonitor.GetBoolAttribute(EBearerIdGPRS, 

                0, 

                KPacketDataAvailability, 

                val, 

                gprsstatus);

        User::WaitForRequest(gprsstatus);

        if(val == EFalse)

            {

            TRequestStatus wcdmastatus;

            iConnectionMonitor.GetBoolAttribute(EBearerIdWCDMA, 

                    0, 

                    KPacketDataAvailability, 

                    val, 

                    wcdmastatus);

            User::WaitForRequest(wcdmastatus);

            if(val != EFalse)

                {

                iConMonBearerId = EBearerIdWCDMA;

                }

            }

        else

            iConMonBearerId = EBearerIdGPRS;

        }

    LOGSTRING("CDMNetworkMon::PacketDataAvailable() ends");

    return val;

    }

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

// CDMNetworkMon::StartOperation

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

void CDMNetworkMon::StartOperationL()

    {

    LOGSTRING("CDMNetworkMon::StartOperation() begins");

    // check for previous state.. If previous state is NetworkDown then do not launch

    // device management session. wait for network up.

    LOGSTRING2("StartOperation() iPrevState = %i",iPrevState );

    LOGSTRING2("StartOperation() iState = %i",iState );

    if(iPrevState!=ENetworkDown)

        StartDeviceManagementSessionL();

    // if previous state is ENetworkDown then wait for Network Up event

    LOGSTRING("CDMNetworkMon::StartOperation() ends");

    }

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

// CDMNetworkMon::CancelGlobalTimer

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

void CDMNetworkMon::CancelGlobalTimer()

    {

    LOGSTRING("CDMNetworkMon::CancelGlobalTimer() begins");

    if ( iGlobalTimer )

        {

        iGlobalTimer->Cancel();

        delete iGlobalTimer;

        iGlobalTimer = NULL;

        }

    LOGSTRING("CDMNetworkMon::CancelGlobalTimer() ends");

    }

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

// CDMNetworkMon::NetworkStable

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

void CDMNetworkMon::NetworkStable()

    {

    LOGSTRING("CDMNetworkMon::NetworkStable() begins");

    // Un-register for events

    //iConnectionMonitor.CancelNotifications();

    iState = EDMJobOk;

    IssueRequest();

    LOGSTRING("CDMNetworkMon::NetworkStable() ends");

    }

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

// CDMNetworkMon::NetworkUp

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

TInt CDMNetworkMon::NetworkUp(TAny* aPtr)

    {

    LOGSTRING("CDMNetworkMon::NetworkUp2() begins");

    CDMNetworkMon* ptr = (CDMNetworkMon*) aPtr;

    if ( ptr->PacketDataAvailable() )

        {

        ptr->NetworkStable();

        }

    LOGSTRING("CDMNetworkMon::NetworkUp2() ends");

    return KErrNone;

    }

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

// CDMNetworkMon::OtherSyncStatus

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

void CDMNetworkMon::OtherSyncStatus()

    {

    LOGSTRING("CDMNetworkMon::OtherSyncStatus() begins");

    iState = EDMJobOk;

    IssueRequest();

    LOGSTRING("CDMNetworkMon::OtherSyncStatus() ends");

    }

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

// CDMNetworkMon::StartDeviceManagementSessionL()

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

void CDMNetworkMon::StartDeviceManagementSessionL()

    {

    LOGSTRING("CDMNetworkMon::StartDeviceManagementSessionL() begins");

    TBool roamingdisabled(EFalse);

    //check if roaming can be enabled from cenrep

    //if(get from cenrep is 1) check if  in roaming 

    //else roamingdisabled is EFalse

    roamingdisabled = IsRoamingDisabled();

    if(roamingdisabled)

        {

        iState = EComplete;

        IssueRequest();

        return;

        }    

    TRAPD(err, CreateDeviceManagementSessionL());

    if(err!=KErrNone)

        {

        CloseSyncSession();

        LOGSTRING2("Error = %i", err);

        iState = EComplete;

        IssueRequest();

        return;  

        }

    LOGSTRING("CDMNetworkMon::StartDeviceManagementSessionL() ends");

    }

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

// CDMNetworkMon::CreateSyncJobL

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

void CDMNetworkMon::CreateDeviceManagementSessionL()

    {

    // close some old Sync Session if existing....

    CloseSyncSession();

    // Open new Sync session

    OpenSyncSessionL();

    LOGSTRING("CDMNetworkMon::CreateDeviceManagementSessionL() begins");

    TBuf8<256> serverid;;	    

    TInt iapid = 0;

    const TUid KUidDeviceManagementKeys = 

    {

            0x101F9A0A 	

    };

    CRepository *repository= CRepository::NewLC ( KUidDeviceManagementKeys ) ;

    TInt err_get = repository->Get(KDevManServerIdKey ,

            serverid);

    LOGTEXT( serverid);

    err_get =  repository->Get(KDevManIapIdKey, iapid);

    LOGSTRING2( "IAPID = %i", iapid);

    CleanupStack::PopAndDestroy(); // CRepository

    // already operation is completed

    if(serverid == KNullDesC8())

        {

        User::Leave(KErrCompletion);

        }	

    RSyncMLDevManProfile ProfileToSearch;

    RArray<TSmlProfileId> arr;

    iSyncSession.ListProfilesL( arr, ESmlDevMan );

    TInt ret = 0;

    TInt ProfileId = KErrNotFound;

    CleanupClosePushL(arr);   	

    for ( TInt index = 0; index < arr.Count(); index++ )

        {

        TRAPD( error, ProfileToSearch.OpenL(iSyncSession, arr[index], ESmlOpenRead ) );

        LOGSTRING2( "error = %i", error);

        if ( error == KErrNone )

            {	            	            	        

            if ( serverid.Compare(ProfileToSearch.ServerId() ) == 0 )

                {

                LOGSTRING("Server profile found");

                ret = 1;                    

                ProfileId = (TInt)arr[index];

                ProfileToSearch.Close();

                break;

                }	            		    

            }

        ProfileToSearch.Close();  

        }

    CleanupStack::PopAndDestroy( &arr );

    if(ret == 1)

        {

        RSyncMLDevManJob dmJob;

        TInt IAPID = -1;

        TBuf<10> genalertap,temp;

        genalertap.Zero();

        temp.Zero();	  

        genalertap.Append(KNSmlDMJobIapPrefix);

        temp.Num(iapid);//Decimal Iap

        if( temp.Length() <= KNSmlHalfTransportIdLength && 

                iapid > KErrNotFound)

            {

            genalertap.AppendFill('0',KNSmlHalfTransportIdLength-temp.Length());

            genalertap.Append(temp);

            TLex gavalue(genalertap);

            gavalue.Val(IAPID);

            LOGSTRING("DM JOB CREATED");

            TRAPD(err, dmJob.CreateL( iSyncSession, ProfileId, IAPID));

            LOGSTRING("DM JOB CREATED END");

            if(err!=KErrNone)

                {

                LOGSTRING2( "error dmJob.CreateL = %i", err);

                User::Leave(err);

                LOGSTRING("DM JOB CREATED END");

                }	

            LOGSTRING("Session created");

            }

        dmJob.Close();

        }

    iSyncSession.RequestEventL( *this ); 

    LOGSTRING("CDMNetworkMon::CreateDeviceManagementSessionL() ends");

    }

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

// CDMNetworkMon::OpenSyncSessionL

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

void CDMNetworkMon::OpenSyncSessionL()

    {

    LOGSTRING("CDMNetworkMon: OpenSyncSessionL() Beigns");

    if (!iSyncSessionOpen)

        {

        TRAPD(err, iSyncSession.OpenL());

        if (err != KErrNone)

            {