/*
* Copyright (c) 2002 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: ?Description
*
*/
// [INCLUDE FILES] - do not remove
#include <e32svr.h>
#include <StifParser.h>
#include <Stiftestinterface.h>
#include "testprofileutil.h"
//SyncML headers
#include <SyncMLDef.h>
#include <SyncMLClient.h>
#include <SyncMLClientDS.h>
#include <SyncMLClientDM.h>
#include <SyncMLTransportProperties.h>
#include <commdb.h>
#include "nsmlconstants.h"
#include "NsmlProfileUtil.h"
// ============================== MEMBER FUNCTIONS ============================
// ----------------------------------------------------------------------------
// CSync::NewL
// Two Phase Construction
// ----------------------------------------------------------------------------
CSync* CSync::NewL(TInt aParam)
{
CSync* self = new (ELeave) CSync;
CleanupStack::PushL(self);
self->ConstructL(aParam);
CleanupStack::Pop(self);
return self;
}
// ----------------------------------------------------------------------------
// CSync::CSync
// Constructor
// ----------------------------------------------------------------------------
CSync::CSync() : CActive(CActive::EPriorityHigh)
{
CActiveScheduler::Add(this);
}
// ----------------------------------------------------------------------------
// CSync::ConstructL
// Second phase constructor
// ----------------------------------------------------------------------------
void CSync::ConstructL(TInt aParam)
{
iPrgPrevStatus = TStatus(-1);
iPrgCurStatus = TStatus(-1);
iState = ERegister;
iInterruptStage=aParam;
IssueRequest();
}
// ----------------------------------------------------------------------------
// CSync::~CSync
// Destructor*
// ----------------------------------------------------------------------------
CSync::~CSync()
{
}
// ----------------------------------------------------------------------------
// CSync::RunL
// ---------------------------------------------------------------------------
void CSync::RunL()
{
switch ( iState )
{
case ERegister:
RegisterL();
break;
case ESyncOk:
StartSyncL();
break;
case EInitSync:
break;
case EComplete:
Complete();
break;
case ECancel:
SyncCancel();
default:
break;
}
}
// ----------------------------------------------------------------------------
// CSync::RunError
// ----------------------------------------------------------------------------
TInt CSync::RunError ( TInt aError )
{
return aError;
}
// ----------------------------------------------------------------------------
// CSync::DoCancel
// ----------------------------------------------------------------------------
void CSync::DoCancel()
{
// Cleanup sync session
CloseSyncSession();
}
// ----------------------------------------------------------------------------
// CSync::RegisterL
// ----------------------------------------------------------------------------
void CSync::RegisterL()
{
// Wait for events
iState = ESyncOk;
IssueRequest();
}
// ----------------------------------------------------------------------------
// CSync::RegisterL
// ----------------------------------------------------------------------------
void CSync::StartSyncL()
{
TBool doSync = EFalse;
OpenSyncSessionL();
// Trigger sync here
// Register for sync events
iSyncSession.RequestEventL(*this); // for MSyncMLEventObserver events
iSyncSession.RequestProgressL(*this); // for MSyncMLProgressObserver events
iSyncJob.CreateL(iSyncSession, 5);
iState = EInitSync;
IssueRequest();
}
// ----------------------------------------------------------------------------
// CSync::SyncCancel
// ----------------------------------------------------------------------------
void CSync::SyncCancel()
{
iSyncSession.CancelEvent();
iSyncSession.Close();
Cancel();
// Close the server
CActiveScheduler::Stop();
}
// ----------------------------------------------------------------------------
// CSync::OpenSyncSessionL
// ----------------------------------------------------------------------------
void CSync::OpenSyncSessionL()
{
TRAPD(err, iSyncSession.OpenL());
if (err != KErrNone)
{
User::Leave(err);
}
}
// ----------------------------------------------------------------------------
// CSync::Complete
// ----------------------------------------------------------------------------
void CSync::Complete()
{
Cancel();
// Close the server
CActiveScheduler::Stop();
}
// ----------------------------------------------------------------------------
// CSync::CloseSyncSession
// ----------------------------------------------------------------------------
void CSync::CloseSyncSession()
{
iSyncSession.CancelEvent();
iSyncSession.Close();
}
// ----------------------------------------------------------------------------
// CSync::EventL
// ----------------------------------------------------------------------------
void CSync::IssueRequest()
{
TRequestStatus* status = &iStatus;
User::RequestComplete(status, KErrNone);
SetActive();
}
// ----------------------------------------------------------------------------
// CSync::OnSyncMLSessionEvent
// ----------------------------------------------------------------------------
void CSync::OnSyncMLSessionEvent(TEvent aEvent,
TInt /*aIdentifier*/,
TInt /*aError*/,
TInt /*aAdditionalData*/)
{
switch ( aEvent )
{
case EJobStart:
break;
case EJobStartFailed:
case EJobRejected:
case ETransportTimeout:
case EServerSuspended:
case EServerTerminated:
case EJobStop:
TInt err(KErrNone);
iState = EComplete;
IssueRequest();
break;
}
}
// -----------------------------------------------------------------------------
// CSync::OnSyncMLSyncError (from MSyncMLProgressObserver)
//
// -----------------------------------------------------------------------------
//
void CSync::OnSyncMLSyncError(TErrorLevel aErrorLevel, TInt aError, TInt /*aTaskId*/, TInt /*aInfo1*/, TInt /*aInfo2*/)
{
//nothing
}
// -----------------------------------------------------------------------------
// CSync::OnSyncMLSyncProgress (from MSyncMLProgressObserver)
//
// -----------------------------------------------------------------------------
//
void CSync::OnSyncMLSyncProgress(TStatus aStatus, TInt aInfo1, TInt /*aInfo2*/)
{
iPrgPrevStatus = iPrgCurStatus;
iPrgCurStatus = aStatus;
switch(iInterruptStage)
{
case 1:if(aStatus==ESmlConnecting)
OfflineModeL();
break;
case 2:if(aStatus==ESmlConnected)
OfflineModeL();
break;
case 3:if(aStatus==ESmlLoggingOn)
OfflineModeL();
break;
case 4:if(aStatus==ESmlLoggedOn)
OfflineModeL();
break;
case 5:if(aStatus==ESmlSendingModificationsToServer)
OfflineModeL();
break;
case 6:if(aStatus==ESmlReceivingModificationsFromServer)
OfflineModeL();
break;
case 7:if(aStatus==ESmlSendingMappingsToServer)
OfflineModeL();
break;
default:
break;
}
}
void CSync::OnSyncMLDataSyncModifications(TInt aTaskId,
const TSyncMLDataSyncModifications& aClientModifications,
const TSyncMLDataSyncModifications& aServerModifications)
{
//Do Nothing
}
void CSync::OfflineModeL()
{
CRepository* repository = CRepository::NewL(KCRUidCoreApplicationUIs);
TInt err = repository->Set(KCoreAppUIsNetworkConnectionAllowed,
ECoreAppUIsNetworkConnectionNotAllowed);
if(repository)
delete repository;
User::LeaveIfError(err);
}