diff -r 000000000000 -r 3ce708148e4d omadm/omadmappui/src/NSmlDMSyncHandler.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/omadm/omadmappui/src/NSmlDMSyncHandler.cpp Thu Dec 17 08:40:12 2009 +0200 @@ -0,0 +1,1244 @@ +/* +* 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: Implementation of DM UI component +* This is part of omadmappui. +* +*/ + + +// INCLUDES +#include +#include +#include +#include // for CTextResolver +#include +#include + +#include // for resource and bitmap directories +#include // sync error codes + + +#include +#include +#include + +#include "NSmlDMSyncDocument.h" +#include "NSmlDMSyncHandler.h" +#include "NSmlDMAuthQueryDlg.h" +#include "NSmlDMSyncState.h" +#include "NSmlDMSyncDebug.h" +#include "NSmlDMSyncDialog.h" +#include "nsmldmsyncinternalpskeys.h" + +#include +#include +#ifdef __SCALABLE_ICONS +_LIT( KBitmapFileName, "z:nsmldmsync.mif" ); +#else +_LIT( KBitmapFileName, "z:nsmldmsync.mbm" ); +#endif + +// ----------------------------------------------------------------------------- +// CNSmlDMSyncHandler::NewL +// +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +CNSmlDMSyncHandler* CNSmlDMSyncHandler::NewL( RSyncMLSession* aSyncSession, + CNSmlDMSyncAppEngine* aAppEngine, + CNSmlDMSyncDocument* aSyncDocument ) + { + FLOG( "CNSmlDMSyncHandler::NewL()" ); + + CNSmlDMSyncHandler* self = + new (ELeave) CNSmlDMSyncHandler( aSyncSession, + aAppEngine, + aSyncDocument ); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +// ----------------------------------------------------------------------------- +// Destructor. +// ----------------------------------------------------------------------------- +// +CNSmlDMSyncHandler::~CNSmlDMSyncHandler() + { + FLOG( "CNSmlDMSyncHandler::~CNSmlDMSyncHandler()" ); + + + if ( iFotaProgressDialog ) + { + TRAP_IGNORE( iFotaProgressDialog->CancelProgressDialogL() ); + delete iFotaProgressDialog; + } + + + if ( iProgressDialog ) + { + TRAP_IGNORE( iProgressDialog->CancelProgressDialogL() ); + delete iProgressDialog; + } + delete iState; + delete iActiveCaller; + + if ( iSyncRunning ) + { + TRAP_IGNORE( iSyncJob.StopL() ); + iSyncJob.Close(); + } + FeatureManager::UnInitializeLib(); + FLOG( "CNSmlDMSyncHandler::~CNSmlDMSyncHandler() completed" ); + } + +// ----------------------------------------------------------------------------- +// CNSmlDMSyncHandler::ConstructL +// Symbian 2nd phase constructor can leave. +// ----------------------------------------------------------------------------- +// +void CNSmlDMSyncHandler::ConstructL( void ) + { + FLOG( "CNSmlDMSyncHandler::ConstructL" ); + FeatureManager::InitializeLibL(); + iState = CNSmlDMSyncState::NewL(); + iActiveCaller = CNSmlDMActiveCaller::NewL(this); + iServerAlertedSync = EFalse; + iSyncRunning = EFalse; + iSyncError = KErrNone; + + iCheckUpdate = EFalse; + + } + +// ----------------------------------------------------------------------------- +// CNSmlDMSyncHandler::CNSmlDMSyncHandler +// ----------------------------------------------------------------------------- +// +CNSmlDMSyncHandler::CNSmlDMSyncHandler( RSyncMLSession* aSyncSession, + CNSmlDMSyncAppEngine* aAppEngine, + CNSmlDMSyncDocument* aSyncDocument ) + : iSyncSession( aSyncSession ), + iSyncAppEngine( aAppEngine ), + iSyncDocument( aSyncDocument ),iFotaProgressLaunched(EFalse) + { + } + +// ----------------------------------------------------------------------------- +// CNSmlDMSyncHandler::HandleDialogEventL +// ----------------------------------------------------------------------------- +// +void CNSmlDMSyncHandler::HandleDialogEventL( TInt aButtonId ) + { + FLOG( "CNSmlDMSyncHandler::HandleDialogEventL" ); + + if ( aButtonId == EEikBidCancel ) + { + FLOG( "CNSmlDMSyncHandler::HandleDialogEventL cancelling" ); + if ( SyncRunning() ) + { + TInt err = RProperty::Set( KPSUidNSmlDMSyncApp, + KDmJobCancel, KErrCancel ); + FTRACE( FPrint( + _L("CNSmlDMSyncHandler::CancelSynchronizeL() KDmJobCancel = -3, err = %d"), + err ) ); + FLOG( "CNSmlDMSyncHandler::HandleDialogEventL cancelling stop job" ); + TRAP_IGNORE( iSyncJob.StopL() ); + + State()->SetSyncPhase( CNSmlDMSyncState::EPhaseCanceling ); + UpdateDialogL(); + } + } + FLOG( "CNSmlDMSyncHandler::HandleDialogEventL() completed" ); + } + +// ----------------------------------------------------------------------------- +// CNSmlDMSyncHandler::SynchronizeL +// ----------------------------------------------------------------------------- +// +void CNSmlDMSyncHandler::SynchronizeL( TDesC& aServerName, + const TInt aProfileId, + const TInt aJobId, + const TInt aConnectionBearer, + const TBool aUseFotaProgressNote ) + { + FLOG( "CNSmlDMSyncHandler::SynchronizeL Server alert" ); + + iServerName = aServerName; + iConnectionBearer = aConnectionBearer; + iProfileId = aProfileId; + iJobId = aJobId; + iUseFotaProgressNote = aUseFotaProgressNote; + + iSyncJob.OpenL( Session(), iJobId ); + iSyncJobId = iSyncJob.Identifier(); + FTRACE( FPrint( _L( + "[OMADM]\tCNSmlDMSyncHandler::SynchronizeL--server alert, iSyncJobId = %d" ), + iSyncJobId ) ); + //SAN Support + iServerAlertedSync = ETrue; + _LIT_SECURITY_POLICY_S0( KWritePolicy, KUidSmlSyncApp.iUid ); + _LIT_SECURITY_POLICY_C1( KReadPolicy, ECapabilityReadDeviceData ); + RProperty::Define( KPSUidNSmlDMSyncApp, + KNSmlDMSyncUiInitiatedJobKey, + RProperty::EInt, + KReadPolicy, + KWritePolicy ); + RProperty::Set( KPSUidNSmlDMSyncApp, + KNSmlDMSyncUiInitiatedJobKey, + iSyncJobId ); + //SAN Support + SynchronizeL(); + } + +// ----------------------------------------------------------------------------- +// CNSmlDMSyncHandler::SynchronizeL +// ----------------------------------------------------------------------------- +// +void CNSmlDMSyncHandler::SynchronizeL( TDesC& aServerName, + const TInt aProfileId, + const TInt aConnectionBearer, + const TBool aUseFotaProgressNote ) + { + FLOG( "CNSmlDMSyncHandler::SynchronizeL" ); + + iServerName = aServerName; + iConnectionBearer = aConnectionBearer; + iProfileId = aProfileId; + iUseFotaProgressNote = aUseFotaProgressNote; + + iSyncJob.CreateL( Session(), iProfileId ); + iSyncJobId = iSyncJob.Identifier(); + SynchronizeL(); + + TInt dummyValue; + TInt err = RProperty::Get( KPSUidNSmlDMSyncApp, + KNSmlDMSyncUiInitiatedJobKey, + dummyValue ); + if ( err == KErrNotFound ) + { + _LIT_SECURITY_POLICY_S0( KWritePolicy, KUidSmlSyncApp.iUid ); + _LIT_SECURITY_POLICY_C1( KReadPolicy, ECapabilityReadDeviceData ); + RProperty::Define( KPSUidNSmlDMSyncApp, + KNSmlDMSyncUiInitiatedJobKey, + RProperty::EInt, + KReadPolicy, + KWritePolicy ); + } + FTRACE( FPrint( _L( + "[OMADM]\tCNSmlDMSyncHandler::SynchronizeL--UI initiated, iSyncJobId = %d" ), + iSyncJobId ) ); + RProperty::Set( KPSUidNSmlDMSyncApp, + KNSmlDMSyncUiInitiatedJobKey, + iSyncJobId ); + } + +// ----------------------------------------------------------------------------- +// CNSmlDMSyncHandler::SynchronizeL +// ----------------------------------------------------------------------------- +// +void CNSmlDMSyncHandler::SynchronizeL() + { + FLOG( "CNSmlDMSyncHandler::SynchronizeL" ); + + TInt err = KErrNone; + + // for MSyncMLEventObserver events + TRAP( err, Session().RequestEventL(*this) ); + if ( err != KErrNone ) + { + iSyncJob.StopL(); + iSyncJob.Close(); + User::Leave(err); + } + + // for MSyncMLProgressObserver events + TRAP( err, Session().RequestProgressL(*this) ); + if ( err != KErrNone ) + { + Session().CancelEvent(); + iSyncJob.StopL(); + iSyncJob.Close(); + User::Leave( err ); + } + + State()->SetSyncPhase( CNSmlDMSyncState::EPhaseConnecting ); + TInt IsDMBusy = EFalse; //IAD: Making DM Idle + TInt r2=RProperty::Get(KUidSmlSyncApp,KDMIdle,IsDMBusy); + if (IsDMBusy) + iNotinFotaView = 1; //Not in fota view + else + iNotinFotaView = 0; //already busy because in other view + IsDMBusy =ETrue; + r2=RProperty::Set(KUidSmlSyncApp,KDMIdle,IsDMBusy); + + TRAP( err, ShowProgressDialogL() ); + if ( err != KErrNone ) + { + Session().CancelEvent(); + Session().CancelProgress(); + iSyncJob.StopL(); + iSyncJob.Close(); + User::Leave( err ); + } + FLOG( "CNSmlDMSyncHandler::SynchronizeL Sync is running" ); + + iSyncDocument->MarkFwUpdChangesStartL(); + + iSyncRunning = ETrue; + iSyncError = KErrNone; + } + +// ----------------------------------------------------------------------------- +// CNSmlDMSyncHandler::SynchronizeCompletedL +// ----------------------------------------------------------------------------- +// +void CNSmlDMSyncHandler::SynchronizeCompletedL( TInt aError ) + { + FTRACE( FPrint( + _L("[OMADM]\t CNSmlDMSyncHandler::SynchronizeCompletedL(), aError = %d"), + aError ) ); + + if ( !SyncRunning() ) + { + FLOG( "CNSmlDMSyncHandler::SynchronizeCompletedL already completed" ); + return; // sync has already completed + } + + iSyncJob.Close(); + + FTRACE( FPrint( _L( + "[OMADM]\tCNSmlDMSyncHandler::SynchronizecompletedL, iSyncJobId = %d" ), + KNSmlDMNoUserInitiatedJob ) ); + // Error code can be ignored. + RProperty::Set( KPSUidNSmlDMSyncApp, + KNSmlDMSyncUiInitiatedJobKey, + KNSmlDMNoUserInitiatedJob ); + + iSyncRunning = EFalse; + iSyncError = aError; + + + iCheckUpdate = EFalse; + + + // close progress dialog + if ( iProgressDialog ) + { + FLOG( "CNSmlDMSyncHandler::SynchronizeCompletedL close dialog" ); + iProgressDialog->CancelProgressDialogL(); + delete iProgressDialog; + iProgressDialog = NULL; + } + + + if ( iFotaProgressDialog ) + { + __ASSERT_ALWAYS( iSyncDocument, TUtil::Panic( KErrGeneral ) ); + + iFotaProgressDialog->CancelProgressDialogL(); + TInt configFlags( EGenericSession ); + //TInt SetGenValue(0); + CRepository* centrep = NULL; + TRAPD( err, centrep = CRepository::NewL( KCRUidDeviceManagementInternalKeys ) ); + if ( centrep ) + { + if( err == KErrNone ) + { + centrep->Get( KDevManSessionType, configFlags ); + } + delete centrep; + } + /*if ( err != KErrNone ) + { + User::Leave( err ); + } + else + { + + centrep->Set( KDevManSessionType, SetGenValue ); + } + if(centrep) + { + delete centrep; + }*/ + delete iFotaProgressDialog; + iFotaProgressDialog = NULL; + // configFlags=2 for FOTA Package not downloaded case ,1- successful download + if ( !iSyncDocument->FwUpdStatesChangedL() && (aError == KErrNone) + && configFlags == EFotaPkgNotFound ) + { + FLOG( "[OMADM]\t CNSmlDMSyncHandler::SynchronizeCompletedL(): No changes in FW Update states." ); + + HBufC* stringHolder = + StringLoader::LoadLC( R_QTN_FOTA_NO_NEW_UPDATES ); + + CAknInformationNote* infoNote = + new (ELeave) CAknInformationNote; + + infoNote->SetTimeout( CAknNoteDialog::ELongTimeout ); + + // We are not interested in the result. + infoNote->ExecuteLD( *stringHolder ); + CleanupStack::PopAndDestroy( stringHolder ); + } + } + + + iUseFotaProgressNote = EFalse; + iSyncJob.Close(); + + // handle error in HandleActiveCallL (when active caller completes) + iActiveCaller->Start( aError ); + + FLOG( "CNSmlDMSyncHandler::SynchronizeCompletedL() completed" ); + } + +// ----------------------------------------------------------------------------- +// CNSmlDMSyncHandler::OnSyncMLSessionEvent +// ----------------------------------------------------------------------------- +// +void CNSmlDMSyncHandler::OnSyncMLSessionEvent( TEvent aEvent, + TInt aIdentifier, + TInt aError, + TInt /*aAdditionalData*/ ) + { + FTRACE( FPrint( _L( + "[OMADM]\tCNSmlDMSyncHandler::OnSyncMLSessionEvent(), aEvent = %d, aIdentifier = %d, aError = %d" ), + aEvent, aIdentifier, aError ) ); + + + if ( aEvent == EJobStop + || aEvent == EJobStartFailed + || aEvent == EJobRejected ) + { + FTRACE( FPrint( _L( + "[OMADM]\tCNSmlDMSyncHandler::OnSyncMLSessionEvent(), iSyncJobId = %d" ), + iSyncJobId ) ); + + + TInt value =EFalse; + TInt r=RProperty::Get( KPSUidNSmlDMSyncApp, KFotaDLStatus, value ); + FTRACE( FPrint( + _L("KFotaDLStatus = %d"),r ) ); + + if(!iNotinFotaView && value != 1 ) + r = RProperty::Set( KPSUidNSmlDMSyncApp, + KDMIdle, KErrNone ); + + + + + + if ( iSyncJobId == aIdentifier ) + { + FLOG( "CNSmlDMSyncHandler::OnSyncMLSessionEvent EJobStop close" ); + //For holding the DM Job session successful / error for future purpose + TInt err = RProperty::Set( KPSUidNSmlDMSyncApp, + KDmJobCancel, KErrNone ); + FTRACE( FPrint( + _L("KDmJobCancel setting in OnSyncMLSessionEvent err = %d"),err ) ); + TRAP_IGNORE( SynchronizeCompletedL( aError ) ); + } + } + FLOG( "[OMADM]\tCNSmlDMSyncHandler::OnSyncMLSessionEvent() completed" ); + } + +// ----------------------------------------------------------------------------- +// CNSmlDMSyncHandler::OnSyncMLSyncError +// ----------------------------------------------------------------------------- +// +void CNSmlDMSyncHandler::OnSyncMLSyncError( TErrorLevel aErrorLevel, + TInt aError, + TInt /*aTaskId*/, + TInt /*aInfo1*/, + TInt /*aInfo2*/) + { + FTRACE( FPrint( _L( + "[OMADM]\tCNSmlDMSyncHandler::OnSyncMLSyncError(), aErrorLevel = %d, aError = %d"), + aErrorLevel, aError ) ); + + if ( aErrorLevel == ESmlFatalError ) + { + TRAP_IGNORE( SynchronizeCompletedL( aError ) ); + } + FLOG( "[OMADM]\tCNSmlDMSyncHandler::OnSyncMLSyncError() completed" ); + } + +// ----------------------------------------------------------------------------- +// CNSmlDMSyncHandler::OnSyncMLSyncProgress +// ----------------------------------------------------------------------------- +// +void CNSmlDMSyncHandler::OnSyncMLSyncProgress( TStatus aStatus, + TInt /*aInfo1*/, + TInt /*aInfo2*/ ) + { + FTRACE( RDebug::Print( + _L("CNSmlDMSyncHandler::OnSyncMLSyncProgress (%d)"), aStatus ) ); + + switch (aStatus) + { + case ESmlConnecting: + State()->SetSyncPhase( CNSmlDMSyncState::EPhaseConnecting ); + break; + case ESmlConnected: + break; + case ESmlLoggingOn: + break; + case ESmlLoggedOn: + State()->SetSyncPhase( CNSmlDMSyncState::EPhaseSynchronizing ); + break; + case ESmlDisconnected: + State()->SetSyncPhase( CNSmlDMSyncState::EPhaseDisconnecting ); + break; + case ESmlCompleted: + State()->SetSyncPhase( CNSmlDMSyncState::EPhaseDisconnecting ); + break; + case ESmlProcessingServerCommands: + State()->SetSyncPhase( CNSmlDMSyncState::EPhaseSending ); + break; + case ESmlReceivingServerCommands: + State()->SetSyncPhase( CNSmlDMSyncState::EPhaseReceiving ); + break; + + case ESmlSendingModificationsToServer: + { + if( iFotaProgressDialog && iCheckUpdate == EFalse ) + { + State()->SetSyncPhase( CNSmlDMSyncState::EPhaseFinal ); + } + + break; + } + + default: + break; + } + TRAP_IGNORE( UpdateDialogL() ); + } + +// ----------------------------------------------------------------------------- +// CNSmlDMSyncHandler::OnSyncMLDataSyncModifications +// ----------------------------------------------------------------------------- +// +void CNSmlDMSyncHandler::OnSyncMLDataSyncModifications( TInt /*aTaskId*/, + const TSyncMLDataSyncModifications& /*aClientModifications*/, + const TSyncMLDataSyncModifications& /*aServerModifications*/ ) + { + FLOG( "CNSmlDMSyncHandler::OnSyncMLDataSyncModifications" ); + + } + +// ----------------------------------------------------------------------------- +// CNSmlDMSyncHandler::GetStatusDialogTextL +// ----------------------------------------------------------------------------- +// +void CNSmlDMSyncHandler::GetStatusDialogTextL( TDes& aBuffer ) + { + FLOG( "CNSmlDMSyncHandler::GetStatusDialogTextL()" ); + + aBuffer = KNullDesC; + TInt phase = State()->SyncPhase(); + + switch ( phase ) + { + case CNSmlDMSyncState::EPhaseConnecting: + { + ReadL( aBuffer, R_SYNCSTATUS_SYNC_CONN ); // "Connecting" + break; + } + case CNSmlDMSyncState::EPhaseSynchronizing: + { + if(iProgressDialog) + ReadL( aBuffer, R_SYNCSTATUS_SYNC_SEND ); // "Synchronizing" + + else if(iFotaProgressDialog ) + ReadL( aBuffer, R_QTN_FOTA_WAIT_CHECKING_UPDATE ); + + break; + } + case CNSmlDMSyncState::EPhaseDisconnecting: + { + + TInt configFlags( EGenericSession ); + CRepository* centrep = NULL; + TRAPD( err, centrep = CRepository::NewL( KCRUidDeviceManagementInternalKeys ) ); + if ( centrep ) + { + centrep->Get( KDevManSessionType, configFlags ); + delete centrep; + } + if ( err != KErrNone ) + { + User::Leave( err ); + } + if( iFotaProgressDialog && configFlags == EGenericSession ) + { + ReadL( aBuffer, R_SYNCSTATUS_SYNC_DISC ); // "Disconnecting" + } + else if( iProgressDialog ) + { + ReadL( aBuffer, R_SYNCSTATUS_SYNC_DISC ); // "Disconnecting" + } + + break; + } + case CNSmlDMSyncState::EPhaseCanceling: + { + ReadL( aBuffer, R_SYNCSTATUS_CANC ); // "Canceling" + break; + } + case CNSmlDMSyncState::EPhaseSending: // ReadProgressText handles both + case CNSmlDMSyncState::EPhaseReceiving: // cases. + { + + if( iProgressDialog ) + { + ReadProgressTextL( aBuffer, State()->Content(), State()->Progress(), + State()->TotalProgress(), phase ); + } + TInt configFlags( EGenericSession ); + CRepository* centrep = NULL; + TRAPD( err, centrep = CRepository::NewL( KCRUidDeviceManagementInternalKeys ) ); + if( centrep ) + { + centrep->Get( KDevManSessionType, configFlags ); + delete centrep; + } + if( err != KErrNone ) + { + User::Leave( err ); + } + if( iFotaProgressDialog && iCheckUpdate && !iFotaProgressLaunched ) + { + ReadProgressTextL( aBuffer, State()->Content(), State()->Progress(), + State()->TotalProgress(), phase ); + TFileName bitmapName; + TParse parse; + parse.Set(KBitmapFileName, &KDC_APP_BITMAP_DIR, NULL); + TUtil::StrCopy(bitmapName, parse.FullName()); + CEikImage* image = iFotaProgressDialog->CreateImageLC(KAknsIIDQgnNoteSml,bitmapName, + EMbmNsmldmsyncQgn_note_sml, + EMbmNsmldmsyncQgn_note_sml_mask); + iFotaProgressDialog->SetImageL(image); + CleanupStack::Pop(image); + } + + break; + } + + case CNSmlDMSyncState::EPhaseFinal: + { + iCheckUpdate = ETrue; + ReadL( aBuffer, R_QTN_FOTA_WAIT_CHECKING_UPDATE ); // "Check for update + TFileName bitmapName; + TParse parse; + parse.Set(KBitmapFileName, &KDC_APP_BITMAP_DIR, NULL); + TUtil::StrCopy(bitmapName, parse.FullName()); + CEikImage* image = iFotaProgressDialog->CreateImageLC(KAknsIIDQgnMenuDm,bitmapName, + EMbmNsmldmsyncQgn_menu_dm, + EMbmNsmldmsyncQgn_menu_dm_mask); + iFotaProgressDialog->SetImageL(image); + CleanupStack::Pop(image); + break; + } + + default: + { + break; + } + } + FLOG( "CNSmlDMSyncHandler::GetStatusDialogTextL() completed" ); + } + +// ----------------------------------------------------------------------------- +// CNSmlDMSyncHandler::UpdateDialogL +// ----------------------------------------------------------------------------- +// +void CNSmlDMSyncHandler::UpdateDialogL() + { + FLOG( "CNSmlDMSyncHandler::UpdateDialogL()" ); + + if ( iProgressDialog ) + { + FLOG( "CNSmlDMSyncHandler::UpdateDialogL(): dialog exists update" ); + TBuf stringHolder; + + TInt phase = State()->SyncPhase(); + + GetStatusDialogTextL( stringHolder ); + if ( stringHolder.Compare( KNullDesC ) != 0 ) // If correct text found + { + Dialog()->UpdateTextL( stringHolder ); + } + + if ( phase == CNSmlDMSyncState::EPhaseSending || + phase == CNSmlDMSyncState::EPhaseReceiving ) + { + if (State()->Progress() == 1) + { + if ( State()->ProgressKnown() ) + { + Dialog()->CancelAnimation(); + Dialog()->SetFinalProgress(State()->TotalProgress()); + Dialog()->SetProgress(State()->Progress()); + } + else + { + Dialog()->SetFinalProgress(0); + Dialog()->StartAnimationL(); + } + } + else if ( State()->ProgressKnown() ) + { + Dialog()->SetProgress( State()->Progress() ); + } + } + } + + else if( iFotaProgressDialog ) + { + FLOG( "CNSmlDMSyncHandler::UpdateDialogL(): fota dialog" ); + TBuf stringHolder; + TInt phase = State()->SyncPhase(); + GetStatusDialogTextL( stringHolder ); + if ( stringHolder.Compare( KNullDesC ) != 0 ) // If correct text found + { + iFotaProgressDialog->UpdateTextL( stringHolder ); + } + + if ( phase == CNSmlDMSyncState::EPhaseSending || + phase == CNSmlDMSyncState::EPhaseReceiving ) + { + if (State()->Progress() == 1) + { + if ( State()->ProgressKnown() ) + { + iFotaProgressDialog->CancelAnimation(); + iFotaProgressDialog->SetFinalProgress(State()->TotalProgress()); + iFotaProgressDialog->SetProgress(State()->Progress()); + } + else + { + iFotaProgressDialog->SetFinalProgress(0); + iFotaProgressDialog->StartAnimationL(); + } + } + else if ( State()->ProgressKnown() ) + { + iFotaProgressDialog->SetProgress( State()->Progress() ); + } + } + } + + FLOG( "CNSmlDMSyncHandler::UpdateDialogL() completed" ); + } + + +// ----------------------------------------------------------------------------- +// CNSmlDMSyncHandler::HandleActiveCallL +// ----------------------------------------------------------------------------- +// +void CNSmlDMSyncHandler::HandleActiveCallL() + { + FLOG( "CNSmlDMSyncHandler::HandleActiveCallL" ); + + // HandleSyncErrorL will set this to true if + // sync will be retried. + iRetrySync = EFalse; + + if ( (iSyncError != KErrNone) && (iSyncError != KErrCancel) ) + { + TRAP_IGNORE( HandleSyncErrorL() ); + } + if ( iRetrySync == EFalse ) + { + // Inform parent that sync is done. + iSyncAppEngine->SyncCompleted( ENSmlSyncComplete ); + } + } + +// ----------------------------------------------------------------------------- +// CNSmlDMSyncHandler::HandleSyncErrorL +// ----------------------------------------------------------------------------- +// +void CNSmlDMSyncHandler::HandleSyncErrorL() + { + FLOG( "CNSmlDMSyncHandler::HandleSyncErrorL" ); + + if ( iSyncError != KDMErr ) + { + GetErrorText( iBuf, iSyncError, iConnectionBearer ); + CAknErrorNote* queryDialog = new (ELeave) CAknErrorNote(ETrue); + if( iSyncDocument->SANSupport() && iSyncDocument->SilentSession() ) + { + queryDialog->SetTone(CAknErrorNote::ENoTone); + } + queryDialog->ExecuteLD( iBuf ); + } + if ( ( iSyncError == SyncMLError::KErrAuthenticationFailure ) || + ( iSyncError == SyncMLError::KErrTransportAuthenticationFailure ) ) + { + TBool httpQuery( iSyncError == SyncMLError::KErrTransportAuthenticationFailure ); + + FLOG( "CNSmlDMSyncHandler::HandleSyncErrorL ask username" ); + + CNSmlDMMultiQuery* dlg = CNSmlDMMultiQuery::NewL( iSyncAppEngine, + iProfileId, + httpQuery ); + if ( dlg->ExecuteLD( R_NSMLDM_AUTHDIALOG ) ) + { + // ok + FLOG( "CNSmlDMSyncHandler::HandleSyncErrorL ask username ok retry sync" ); + iRetrySync = ETrue; + // We have already closed job so create a new. + iSyncJob.CreateL( Session(), iProfileId ); + iSyncJobId = iSyncJob.Identifier(); + SynchronizeL(); + } + else + { + FLOG( "CNSmlDMSyncHandler::HandleSyncErrorL ask username cancel" ); + } + } + } + +// ----------------------------------------------------------------------------- +// CNSmlDMSyncHandler::GetErrorTextL +// ----------------------------------------------------------------------------- +// +void CNSmlDMSyncHandler::GetErrorText( TDes& aErrorText, + TInt aErrorCode, + TInt aTransport ) + { + FTRACE( RDebug::Print( + _L("CNSmlDMSyncHandler::GetErrorText Errorcode (%d)"), aErrorCode) ); + + aErrorText = KNullDesC(); + + TInt id = R_QTN_DM_LOG_ERR_SYSTEMERROR; // "System Error" + + switch ( aErrorCode ) + { + case SyncMLError::KErrTransportAuthenticationFailure: + { + if ( aTransport == EAspBearerInternet ) + { + // "Http authentication failed" + id = R_QTN_NSML_LOG_ERR_CLIENTAUTH; + } + else + { + // "Invalid user name or password" + id = R_QTN_DM_LOG_ERR_CLIENTAUTH; + } + break; + } + + case SyncMLError::KErrAuthenticationFailure: + { + // "Invalid user name or password" + id = R_QTN_DM_LOG_ERR_CLIENTAUTH; + break; + } + + case KErrServerBusy: + { + // "Synchronisation server was busy" + id = R_QTN_DM_LOG_ERR_SERVERBUSY; + break; + } + + case SyncMLError::KErrServerDatabaseNotFound: + { + // "Invalid remote database" + id = R_QTN_DM_LOG_ERR_SESSIONABORT; + break; + } + + case SyncMLError::KErrConnectionError: + { + // "Server is not responding" + id = R_QTN_DM_LOG_ERR_SERVERNOTRESPONDING; + break; + } + + case SyncMLError::KErrTransportSvrNoUri: + { + // "Invalid host address" + id = R_QTN_DM_LOG_ERR_URIINVALID; + break; + } + case SyncMLError::KErrTransportDisconnected: + { + id = R_QTN_DM_LOG_ERR_TIMEDOUT; + break; + } + + case SyncMLError::KErrTransportRequest: + case SyncMLError::KErrTransportHeader: + case SyncMLError::KErrTransportSvrError: + case SyncMLError::KErrCannotCommunicateWithServer: + { + // "Error in communication" + id = R_QTN_DM_LOG_ERR_COMM; + break; + } + + case SyncMLError::KErrVerDTDMissing: + case SyncMLError::KErrProtoMissing: + case SyncMLError::KErrVersionDTDNotSupported: + case SyncMLError::KErrProtoNotSupported: + { + // "Unsupported SyncML software version in server" + id = R_QTN_DM_LOG_ERR_VERSIONNOTSUPPORTED; + break; + } + + case SyncMLError::KErrSessionIdNotValid: + case SyncMLError::KErrMappingInfoMissing: + case SyncMLError::KErrMappingInfoNotAcked: + case SyncMLError::KErrStatusCommandForCommandNotSent: + case SyncMLError::KErrStatusCommandNotTheSame: + case SyncMLError::KErrMissingStatusCommands: + case SyncMLError::KErrFailedToAddRecord: + case SyncMLError::KErrFailedToReplaceRecord: + case SyncMLError::KErrFailedToDeleteRecord: + case SyncMLError::KErrXmlParsingError: + case SyncMLError::KErrReferenceToolkitError: + case SyncMLError::KErrObjectTooLargeToSendToServer: + case SyncMLError::KErrFailedToGetRecord: + case SyncMLError::KErrUserInteractionFailed: + case SyncMLError::KErrStatusSizeMismatch: + case SyncMLError::KErrFailedToCloseDatabase: + case SyncMLError::KErrDatabaseAdapterIndexError: + case SyncMLError::KErrClientDatabaseNotFound: + { + // "Error in sync server" + id = R_QTN_DM_LOG_ERR_SERVERERROR; + break; + } + case SyncMLError::KErrPhoneOnOfflineMode: + { + // "Phone in offline" + id = R_QTN_DM_LOG_ERR_OFFLINE; + break; + } + + case SyncMLError::KErrInvalidCredentials: + { + // Server authentication failed + id = R_QTN_DM_LOG_ERR_SERVERTAUTH; + break; + } + + //TARM Enabled build Server profile Cert not stored or invalid + case SyncMLError::KErrInvalidCert: + { + if(FeatureManager::FeatureSupported(KFeatureIdSapPolicyManagement)) + { + id = R_QTN_DM_ERROR_UNTRUSTED_CERT ; + } + break; + } + default: + { + if ( ( aErrorCode == KErrDiskFull ) || + ( aErrorCode == KErrNoMemory ) ) + { + TRAPD( retVal, SetErrorMessageL( aErrorCode, aErrorText ) ); + if ( retVal == KErrNone ) + { + return; + } + } + // "System Error" + id = R_QTN_DM_LOG_ERR_SYSTEMERROR; + break; + } + } + + TRAP_IGNORE( ReadL( aErrorText, id ) ); + } + +// ----------------------------------------------------------------------------- +// CNSmlDMSyncHandler::ShowProgressDialogL +// ----------------------------------------------------------------------------- +// +void CNSmlDMSyncHandler::ShowProgressDialogL( ) + { + FLOG( "CNSmlDMSyncHandler::ShowProgressDialogL" ); + + delete iProgressDialog; + iProgressDialog = NULL; + + if ( iUseFotaProgressNote ) + { + + iFotaProgressDialog = CNSmlDMProgressDialog::NewL( this ); + iFotaProgressLaunched = ETrue; + TBuf buf; + GetStatusDialogTextL( buf ); + TFileName bitmapName; + TParse parse; + parse.Set(KBitmapFileName, &KDC_APP_BITMAP_DIR, NULL); + TUtil::StrCopy(bitmapName, parse.FullName()); + + if ( iServerAlertedSync ) + { + iFotaProgressDialog->LaunchProgressDialogL( + buf, + KAknsIIDQgnNoteSml, + bitmapName, + EMbmNsmldmsyncQgn_note_sml_server, + EMbmNsmldmsyncQgn_note_sml_server_mask ); + } + else + { + iFotaProgressDialog->LaunchProgressDialogL( + buf, + KAknsIIDQgnNoteSml, + bitmapName, + EMbmNsmldmsyncQgn_note_sml, + EMbmNsmldmsyncQgn_note_sml_mask ); + } + iFotaProgressLaunched = EFalse; + UpdateDialogL(); + + } + else + { + iProgressDialog = CNSmlDMProgressDialog::NewL( this ); + + TBuf buf; + GetStatusDialogTextL( buf ); + + TFileName bitmapName; + TParse parse; + parse.Set(KBitmapFileName, &KDC_APP_BITMAP_DIR, NULL); + TUtil::StrCopy(bitmapName, parse.FullName()); + + if ( iServerAlertedSync ) + { + iProgressDialog->LaunchProgressDialogL( + buf, + KAknsIIDQgnNoteSml, + bitmapName, + EMbmNsmldmsyncQgn_note_sml_server, + EMbmNsmldmsyncQgn_note_sml_server_mask ); + } + else + { + iProgressDialog->LaunchProgressDialogL( + buf, + KAknsIIDQgnNoteSml, + bitmapName, + EMbmNsmldmsyncQgn_note_sml, + EMbmNsmldmsyncQgn_note_sml_mask ); + } + UpdateDialogL(); + } + + FLOG( "CNSmlDMSyncHandler::ShowProgressDialogL() completed" ); + } + +// ----------------------------------------------------------------------------- +// CNSmlDMSyncHandler::HideProgressDialogL +// ----------------------------------------------------------------------------- +// +void CNSmlDMSyncHandler::HideProgressDialogL() + { + FLOG( "CNSmlDMSyncHandler::HideProgressDialogL" ); + + + if ( iFotaProgressDialog ) + { + FLOG( "CNSmlDMSyncHandler::HideProgressDialogL dialog exists hide it" ); + iFotaProgressDialog->CancelProgressDialogL(); + delete iFotaProgressDialog; + iFotaProgressDialog = NULL; + } + + if ( iProgressDialog ) + { + FLOG( "CNSmlDMSyncHandler::HideProgressDialogL dialog exists hide it" ); + iProgressDialog->CancelProgressDialogL(); + delete iProgressDialog; + iProgressDialog = NULL; + } + } + +// ----------------------------------------------------------------------------- +// CNSmlDMSyncHandler::SetErrorMessageL +// +// Set synchronisation error message text. +// ----------------------------------------------------------------------------- +// +void CNSmlDMSyncHandler::SetErrorMessageL(TInt aError, TDes& aMsg) + { + FLOG( "CNSmlDMSyncHandler::SetErrorMessageL" ); + + CTextResolver* textResolver = CTextResolver::NewLC(); + + aMsg.Append( textResolver->ResolveErrorString( aError, + CTextResolver::ECtxNoCtx ) ); + + CleanupStack::PopAndDestroy( textResolver ); + + TBuf buf; + ReadL( buf, R_SML_APP_TITLE ); + TUtil::StrInsert( aMsg, buf ); + } + +// ----------------------------------------------------------------------------- +// CNSmlDMSyncHandler::Session +// ----------------------------------------------------------------------------- +// +RSyncMLSession& CNSmlDMSyncHandler::Session() + { + __ASSERT_DEBUG(iSyncSession, TUtil::Panic(KErrGeneral)); + + return *iSyncSession; + } + +// ----------------------------------------------------------------------------- +// CNSmlDMSyncHandler::Dialog +// ----------------------------------------------------------------------------- +// +CNSmlDMProgressDialog* CNSmlDMSyncHandler::Dialog() + { + __ASSERT_DEBUG(iProgressDialog, TUtil::Panic(KErrGeneral)); + + return iProgressDialog; + } + + +// ----------------------------------------------------------------------------- +// CNSmlDMSyncHandler::SyncRunning +// ----------------------------------------------------------------------------- +// +TBool CNSmlDMSyncHandler::SyncRunning() + { + FTRACE( RDebug::Print( + _L("CNSmlDMSyncHandler::SyncRunning status (%d)"), iSyncRunning ) ); + + return iSyncRunning; + } + +// ----------------------------------------------------------------------------- +// CNSmlDMSyncHandler::State +// ----------------------------------------------------------------------------- +// +CNSmlDMSyncState* CNSmlDMSyncHandler::State() + { + __ASSERT_DEBUG(iState, TUtil::Panic(KErrGeneral)); + + return iState; + } + +// ----------------------------------------------------------------------------- +// CNSmlDMSyncHandler::ReadL +// ----------------------------------------------------------------------------- +// +void CNSmlDMSyncHandler::ReadL( TDes& aText, TInt aResourceId ) + { + FLOG( "CNSmlDMSyncHandler::ReadL" ); + + HBufC* buf = StringLoader::LoadLC( aResourceId ); + TUtil::StrCopy( aText, *buf ); + CleanupStack::PopAndDestroy( buf ); + } + +// ----------------------------------------------------------------------------- +// CNSmlDMSyncHandler::ReadProgressTextL +// ----------------------------------------------------------------------------- +// +void CNSmlDMSyncHandler::ReadProgressTextL( TDes& aText, + const TDesC& /*aContent*/, + TInt /*aCurrent*/, + TInt aFinal, + TInt aPhase ) + { + FLOG( "CNSmlDMSyncHandler::ReadProgressTextL" ); + + aText = KNullDesC; + + HBufC* buf = NULL; + + TBool send = EFalse; + if ( aPhase == CNSmlDMSyncState::EPhaseSending ) + { + send = ETrue; + } + if ( send && aFinal == -1 ) + { + buf = StringLoader::LoadLC( R_SYNCSTATUS_SYNC_SEND, iServerName ); + } + if ( send && aFinal >= 0 ) + { + buf = StringLoader::LoadLC( R_SYNCSTATUS_SYNC_SEND, iServerName ); + } + if ( !send && aFinal == -1 ) + { + buf = StringLoader::LoadLC( R_SYNCSTATUS_SYNC_RECV, iServerName ); + } + if ( !send && aFinal >= 0 ) + { + buf = StringLoader::LoadLC( R_SYNCSTATUS_SYNC_RECV, iServerName ); + } + + if ( buf ) + { + TUtil::StrCopy( aText, *buf ); + CleanupStack::PopAndDestroy( buf ); + } + } + +// ----------------------------------------------------------------------------- +// CNSmlDMSyncHandler::CancelSynchronizeL +// ----------------------------------------------------------------------------- +// +void CNSmlDMSyncHandler::CancelSynchronizeL() + { + FLOG( "CNSmlDMSyncHandler::CancelSynchronizeL" ); + + if ( iSyncRunning ) + { + iSyncJob.StopL(); + TInt err = RProperty::Set( KPSUidNSmlDMSyncApp, + KDmJobCancel, KErrCancel); + FTRACE( FPrint( + _L( "CNSmlDMSyncHandler::CancelSynchronizeL() KDmJobCancel=-3, err = %d" ), + err ) ); + SynchronizeCompletedL( KErrCancel ); + } + } + +// ----------------------------------------------------------------------------- +// CNSmlDMSyncHandler::DialogDismissedL +// ----------------------------------------------------------------------------- +// +void CNSmlDMSyncHandler::DialogDismissedL( TInt aButtonId ) + { + FTRACE( FPrint( + _L( "CNSmlDMSyncHandler::DialogDismissedL(), aButtonId = %d" ), + aButtonId ) ); + + HandleDialogEventL( aButtonId ); + + FLOG( "CNSmlDMSyncHandler::DialogDismissedL() completed" ); + } + +// End of File