--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/syncmlfw/dm/dmnetworkmon/src/DMNetworkMon.cpp Thu Dec 17 09:07:52 2009 +0200
@@ -0,0 +1,825 @@
+/*
+ * 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)
+ {
+ LOGSTRING("CDMNetworkMon: RSyncMLSession::OpenL failed ");
+ User::Leave(err);
+ }
+ }
+ iSyncSessionOpen = ETrue;
+
+ LOGSTRING("CDMNetworkMon: OpenSyncSessionL() Ends");
+ }
+
+// ----------------------------------------------------------------------------
+// CDMNetworkMon::Complete
+// ----------------------------------------------------------------------------
+void CDMNetworkMon::Complete()
+ {
+ LOGSTRING("CDMNetworkMon::Complete() begins");
+
+ Cancel();
+
+ // Close the server
+ CActiveScheduler::Stop();
+
+ LOGSTRING("CDMNetworkMon::Complete() ends");
+ }
+
+// ----------------------------------------------------------------------------
+// CDMNetworkMon::CloseSyncSession
+// ----------------------------------------------------------------------------
+void CDMNetworkMon::CloseSyncSession()
+ {
+ LOGSTRING("CDMNetworkMon::CloseSyncSession() begins");
+
+ if (iSyncSessionOpen)
+ {
+ iSyncSession.CancelEvent();
+ iSyncSession.Close();
+ iSyncSessionOpen = EFalse;
+ }
+
+ LOGSTRING("CDMNetworkMon::CloseSyncSession() ends");
+ }
+
+
+// ----------------------------------------------------------------------------
+// CDMNetworkMon::EventL
+// ----------------------------------------------------------------------------
+void CDMNetworkMon::EventL ( const CConnMonEventBase& aEvent )
+ {
+ DBG_FILE_CODE(aEvent.ConnectionId(), _S8(" CDMNetworkMon::EventL() The Connection ID is:"));
+ const CConnMonNetworkStatusChange * eventNetworkStatus;
+ eventNetworkStatus = ( const CConnMonNetworkStatusChange* ) &aEvent;
+
+ LOGSTRING2( "Event Network = %i",aEvent.EventType());
+ LOGSTRING( "Event Visited");
+
+ switch ( aEvent.EventType() )
+ {
+ case EConnMonPacketDataAvailable:
+ {
+ if ( aEvent.ConnectionId() == EBearerIdGPRS ||
+ aEvent.ConnectionId() == EBearerIdWCDMA )
+ {
+
+ LOGSTRING("CDMNetworkMon::EventL() Packet Data is available");
+ iConMonBearerId = TConnMonBearerId(aEvent.ConnectionId());
+
+ // Once packetdata is available set the state to ENetworkUp
+ // check if previous state is NetworkDown then set to Network Up and
+ // again device management session can be started
+
+ if(iPrevState == ENetworkDown)
+ {
+ iState = ENetworkUp;
+ IssueRequest();
+ }
+ }
+
+ break;
+ }
+
+ case EConnMonNetworkStatusChange:
+ {
+ LOGSTRING("CDMNetworkMon::EventL() Packet Data is EConnMonNetworkStatusChange");
+ LOGSTRING2( "Event Network Status= %i",eventNetworkStatus->NetworkStatus());
+ switch(eventNetworkStatus->NetworkStatus())
+ {
+ //Network Down Scenario
+ case EConnMonStatusNotAvailable:
+ //General to Offline Scenario
+ case EConnMonStatusUnattached:
+ //Incoming Voice Call Scenario
+ case EConnMonStatusSuspended:
+ {
+ iState = ENetworkDown;
+ }
+ break;
+ }
+ }
+ break;
+
+ case EConnMonPacketDataUnavailable:
+ {
+ LOGSTRING("CDMNetworkMon::EventL() Packet Data is EConnMonPacketDataUnavailable");
+ iState = ENetworkDown;
+ }
+ break;
+
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CDMNetworkMon::EventL
+// ----------------------------------------------------------------------------
+void CDMNetworkMon::IssueRequest()
+ {
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete(status, KErrNone);
+ SetActive();
+ }
+
+// ----------------------------------------------------------------------------
+// CDMNetworkMon::OnSyncMLSessionEvent
+// ----------------------------------------------------------------------------
+void CDMNetworkMon::OnSyncMLSessionEvent(TEvent aEvent,
+ TInt /*aIdentifier*/,
+ TInt /*aError*/,
+ TInt /*aAdditionalData*/)
+ {
+ LOGSTRING2( "Event = %i", aEvent);
+ LOGSTRING2( "iState = %i", iState);
+ switch ( aEvent )
+ {
+ case EJobStart:
+ LOGSTRING("CDMNetworkMon::OnSyncMLSessionEvent() Sync job started");
+ break;
+
+ case EJobStartFailed:
+ case EJobRejected:
+ case ETransportTimeout:
+ case EServerSuspended:
+ case EServerTerminated:
+ case EJobStop:
+ {
+ #ifdef __WINS__
+ {
+ //No monitoring required for emulator.
+ iState = EComplete;
+ IssueRequest();
+
+ }
+ #else
+ {
+ if(iState != ENetworkDown && iError == KErrNone)
+ {
+ LOGSTRING("CDMNetworkMon::OnSyncMLSessionEvent() Sync job stopped and job stop not because of Network Down");
+
+ iState = EComplete;
+ IssueRequest();
+ }
+ else
+ {
+ if(iState == ENetworkDown)
+ {
+ LOGSTRING("CDMNetworkMon::OnSyncMLSessionEvent() Sync job stopped and job stop because of Network Down");
+ iPrevState = ENetworkDown;
+ }
+ iState = EMonitor;
+ IssueRequest();
+ }
+ }
+ #endif
+ }
+ break;
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CDMNetworkMon::UpdateInterruptFlagL
+// ----------------------------------------------------------------------------
+TBool CDMNetworkMon::IsRoamingDisabled()
+ {
+
+ TBool roamingDisabled(EFalse);
+ TRequestStatus status;
+ TInt roamingStatus(0);
+ if( iConMonBearerId != TConnMonBearerId(-1))
+ {
+ iConnectionMonitor.GetIntAttribute(iConMonBearerId,
+ 0,
+ KNetworkRegistration,
+ roamingStatus,
+ status);
+
+ User::WaitForRequest(status);
+ }
+
+
+ if ( roamingStatus == ENetworkRegistrationRoaming )
+ {
+ LOGSTRING("CDMNetworkMon::IsRoamingDisabled() Device NOT in home network");
+ roamingDisabled = ETrue;
+ }
+
+ return roamingDisabled;
+ }
+
+
+
+
+// ----------------------------------------------------------------------------
+// CDMNetworkMon::Timeout
+// ----------------------------------------------------------------------------
+TInt CDMNetworkMon::Timeout(TAny* aPtr)
+ {
+ LOGSTRING("CDMNetworkMon::Timeout() begins");
+
+ CDMNetworkMon* ptr = (CDMNetworkMon*) aPtr;
+
+ DBG_FILE_CODE(ptr->iTimerCount, _S8("CDMNetworkMon::Timeout() The time out count is"));
+
+ ptr->iTimerCount = ptr->iTimerCount + 1;
+
+ if(ptr->iTimerCount == (ptr->iGlobalTimeout * 2))
+ {
+ ptr->iTimerCount = 0;
+
+ ptr->CancelGlobalTimer();
+ ptr->Complete();
+ }
+
+ LOGSTRING("CDMNetworkMon::Timeout() ends");
+
+ return KErrNone;
+ }
+
+// ----------------------------------------------------------------------------
+// CDMNetworkMon::ReadTimeoutFromCenrepL
+// ----------------------------------------------------------------------------
+TInt CDMNetworkMon::ReadTimeoutFromCenrepL()
+ {
+ LOGSTRING("CDMNetworkMon::ReadTimeoutFromCenrepL() begins");
+
+ TInt timeoutInHours = 24;
+
+ // Read the value from cenrep
+ CRepository* repository = CRepository::NewLC(KCRUidDeviceManagementInternalKeys);
+ repository->Get(KDevManNetMonTimeoutKey, timeoutInHours);
+ CleanupStack::PopAndDestroy(repository);
+
+ LOGSTRING("CDMNetworkMon::ReadTimeoutFromCenrepL() ends");
+
+ return timeoutInHours;
+ }
+
+// -----------------------------------------------------------------------------
+// CDMNetworkMon::OnSyncMLSyncError (from MSyncMLProgressObserver)
+//
+// -----------------------------------------------------------------------------
+//
+void CDMNetworkMon::OnSyncMLSyncError(TErrorLevel aErrorLevel, TInt aError, TInt /*aTaskId*/, TInt /*aInfo1*/, TInt /*aInfo2*/)
+ {
+ LOGSTRING2("CDMNetworkMon::OnSyncMLSyncError ERROR = %i", aError);
+ iError = aError;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CDMNetworkMon::OnSyncMLSyncProgress (from MSyncMLProgressObserver)
+//
+// -----------------------------------------------------------------------------
+//
+void CDMNetworkMon::OnSyncMLSyncProgress(TStatus aStatus, TInt aInfo1, TInt /*aInfo2*/)
+ {
+ DBG_FILE( _S8("CDMNetworkMon::OnSyncMLSyncProgress START") );
+
+
+ LOGSTRING2("CDMNetworkMon::OnSyncMLSyncProgress Status = %i", aStatus);
+
+ DBG_FILE( _S8("CDMNetworkMon::OnSyncMLSyncProgress END") );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CDMNetworkMon::OnSyncMLDataSyncModifications (from MSyncMLProgressObserver)
+//
+// -----------------------------------------------------------------------------
+//
+void CDMNetworkMon::OnSyncMLDataSyncModifications(TInt aTaskId,
+ const TSyncMLDataSyncModifications& aClientModifications,
+ const TSyncMLDataSyncModifications& aServerModifications)
+ {
+ //Do Nothing
+ }
+
+
+
+// End of file
+