FCL/sf/app/commonemail: comparison ipsservices/ipssosaoplugin/src/IpsSosAOMboxLogic.cpp

equal deleted inserted replaced

-:dcf0eedfc1a3
+:d189ee25cf9d
 /*
-* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).
+* 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".
 * Description:
 *     Contains mailbox specified always online logic
 *
 */
+#include "ipssosaopluginheaders.h"
-//<cmail> internal dependency removed
-/*#ifdef _DEBUG
+//<QMail>
-#include "../../internal/IpsSosAOPluginTester/inc/IpsSosAOPluginTester.hrh"
-#endif // _DEBUG*/
-//</cmail>
-#include <cmmanager.h>
-#include "emailtrace.h"
-#include "IpsSosAOMboxLogic.h"
-#include "ipssetdataapi.h"
-#include "IpsSosAOSchedulerUtils.h"
-#include "IpsSosAOPlugin.hrh"
-#include "IpsSosAOImapPopLogic.h"
 const TInt KAOSecondsInMinute = 60;
+//</QMail>
 const TInt KIpsSosAOMboxLogicMinGra = 1;
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 //
 CIpsSosAOMBoxLogic::CIpsSosAOMBoxLogic(
 CMsvSession& aSession,
 TMsvId aMailboxId ) :
 iSession( aSession ), iMailboxId( aMailboxId ), iState( EStateError ),
 iErrorCounter( 0 ), iError( KErrNone ), iTimer( NULL ),
-iFetchMsgArray( KIpsSosAOMboxLogicMinGra ), iDataApi( NULL ), iAgent( NULL ),
+	//<QMail>
-iExtendedSettings( NULL ), iIsRoaming( EFalse )
+iFetchMsgArray( KIpsSosAOMboxLogicMinGra ), iAgent( NULL ),
+iIsRoaming( EFalse )
+	//</QMail>
 {
 FUNC_LOG;
 }
 // ----------------------------------------------------------------------------
 //
 CIpsSosAOMBoxLogic::~CIpsSosAOMBoxLogic()
 {
 FUNC_LOG;
 delete iTimer;
-delete iDataApi;
+	//<QMail>
-delete iExtendedSettings;
+	//</QMail>
 delete iAgent;
 iFetchMsgArray.Close();
 }
 // ----------------------------------------------------------------------------
 //
 void CIpsSosAOMBoxLogic::ConstructL()
 {
 FUNC_LOG;
 iTimer = CIpsSosAOPluginTimer::NewL( CActive::EPriorityStandard, *this );
-iDataApi = CIpsSetDataApi::NewL( iSession );
+	//<QMail>
 iAgent = CIpsSosAOBaseAgent::CreateAgentL( iSession, *this, iMailboxId );
-LoadSettingsL();
+//</QMail>
 }
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 //
 // ----------------------------------------------------------------------------
 //
 void CIpsSosAOMBoxLogic::FetchMessagesL( const RArray<TMsvId> aArray )
 {
 FUNC_LOG;
-LoadSettingsL();
+//<Qmail>
+//</Qmail>
 for ( TInt i = 0; i < aArray.Count(); i++ )
 {
 iFetchMsgArray.AppendL( aArray[i] );
 }
 HandleEventAndSwitchStateL( EEventFetchMessages );
 //
 TBool CIpsSosAOMBoxLogic::IsEmnOn() const
 {
 FUNC_LOG;
 TBool ret = ETrue;
-TIpsSetDataEmnStates state = EMailEmnOff;
+	//<QMail>
-if ( iExtendedSettings )
+CIpsSosAOSettingsHandler* settings = NULL;
-{
+TRAP_IGNORE( settings =
-state = iExtendedSettings->EmailNotificationState();
+CIpsSosAOSettingsHandler::NewL(iSession, iMailboxId));
-}
-if ( state == EMailEmnOff )
+if( settings )
 {
-ret = EFalse;
+IpsServices::TIpsSetDataEmnStates state = IpsServices::EMailEmnOff;
-}
+state = settings->EmailNotificationState();
+if ( state == IpsServices::EMailEmnOff )
+{
+ret = EFalse;
+}
+delete settings;
+}
+	//</QMail>
 return ret;
 }
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 //
+//<QMail>
 void CIpsSosAOMBoxLogic::GetEmailAddress(
 TBuf<KIpsSosAOTextBufferSize>& aEmailAddress ) const
 {
 FUNC_LOG;
-const TDesC& addr = iExtendedSettings->EmailAddress();
+CIpsSosAOSettingsHandler* settings = NULL;
-__ASSERT_DEBUG( (
-addr.Length() <= KIpsSosAOTextBufferSize ),
+TRAPD( err, settings = CIpsSosAOSettingsHandler::NewL(
-User::Panic( KIpsSosAOPanicLit, KErrGeneral) );
+iSession, iMailboxId) );
-if ( addr.Length() <= KIpsSosAOTextBufferSize )
+if( settings )
 {
-aEmailAddress.Copy( addr );
+HBufC* addr = NULL;
-}
+TRAP(err, addr = settings->EmailAddressL());
-}
+if( addr )
-// ----------------------------------------------------------------------------
+{
-// ----------------------------------------------------------------------------
+__ASSERT_DEBUG( (
-//
+addr->Length() <= KIpsSosAOTextBufferSize ),
-//<cmail>
+User::Panic( KIpsSosAOPanicLit, KErrGeneral) );
+if ( addr->Length() <= KIpsSosAOTextBufferSize )
+{
+aEmailAddress.Copy( *addr );
+}
+delete addr;
+}
+delete settings;
+}
+	//<QMail>
+}
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+//<QMail>
 void CIpsSosAOMBoxLogic::SetEmnReceivedFlagL( TBool aNewValue )
-//</cmail>
+{
-{
-LoadSettingsL();
+CIpsSosAOSettingsHandler* settings =
-iExtendedSettings->SetEmnReceivedButNotSyncedFlag( aNewValue );
+CIpsSosAOSettingsHandler::NewL(
-iDataApi->SaveExtendedSettingsL(
+iSession, iMailboxId );
-*iExtendedSettings );
+CleanupStack::PushL(settings);
+settings->SetEmnReceivedButNotSyncedFlag( aNewValue );
+CleanupStack::PopAndDestroy(settings);
+	//</QMail>
 }
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 //
-//<cmail>
 TBool CIpsSosAOMBoxLogic::IsMailboxRoamingStoppedL()
-//</cmail>
 {
 TBool ret = EFalse;
 if ( iIsRoaming && !CanConnectIfRoamingL() )
 {
 ret = ETrue;
 FUNC_LOG;
 TInt event = aEvent;
 TInt cycles = 0;
 if ( event == EEventStart && iState == EStateError &&
-CanConnectIfRoamingL() )
+( (iIsRoaming && CanConnectIfRoamingL())||
-{
+!iIsRoaming ) )
+{
+NM_COMMENT("CIpsSosAOMBoxLogic: event: EEventStart");
 event = EEventNop;
 iAgent->LoadSettingsL();
 iTimer->Cancel();
+INFO_1("CIpsSosAOMBoxLogic: timer scheduled: %d", KIpsSosAOStartDelaySeconds);
 iTimer->After( KIpsSosAOStartDelaySeconds );
 iState = EStateWaitSyncStart;
+NM_COMMENT("CIpsSosAOMBoxLogic: switching state: EStateWaitSyncStart");
 }
 while ( event != EEventNop && iState != EStateError )
 {
-//<cmail> removing flags
-/*#ifdef IPSSOSIMAPPOLOGGING_ON
-WriteDebugData( event );
-#endif*/
-//</cmail>
 switch ( event )
 {
 case EEventTimerFired:
+NM_COMMENT("CIpsSosAOMBoxLogic: event: EEventTimerFired");
 event = HandleTimerFiredL();
 break;
 case EEventStartSync:
+NM_COMMENT("CIpsSosAOMBoxLogic: event: EEventStartSync");
 if ( iState == EStateWaitSyncStart )
 {
 iError = KErrNone;
 iAgent->StartSyncL();
 iState = EStateSyncOngoing;
+NM_COMMENT("CIpsSosAOMBoxLogic: switching state: EStateSyncOngoing");
 }
 else if ( iState == EStateIdleAndWaitCommands )
 {
 // start sync command in idle state is currently
 // received when emn arrives, checking scheduling
 // if user have selected week days / hours in setting
+					//<QMail>
+CIpsSosAOSettingsHandler* settings =
+CIpsSosAOSettingsHandler::NewL(iSession, iMailboxId);
+CleanupStack::PushL(settings);
 CIpsSosAOSchedulerUtils* scheduler =
-CIpsSosAOSchedulerUtils::NewLC( *iExtendedSettings );
+CIpsSosAOSchedulerUtils::NewLC( *settings );
 TTimeIntervalSeconds seconds;
 TIpsSosAOConnectionType type =
 scheduler->SecondsToNextMark( seconds );
+					//</QMail>
 if ( type == EAOCConnectAfter )
 {
+NM_COMMENT("CIpsSosAOMBoxLogic: switching state: EStateWaitSyncStart");
 iState = EStateWaitSyncStart;
+INFO_1("CIpsSosAOMBoxLogic: timer scheduled: %d", seconds);
 iTimer->After( seconds );
-//<cmail>
 SetEmnReceivedFlagL( ETrue );
-//</cmail>
 }
 else
 {
 iError = KErrNone;
 iAgent->StartSyncL();
 iState = EStateSyncOngoing;
+NM_COMMENT("CIpsSosAOMBoxLogic: switching state: EStateSyncOngoing");
 }
-CleanupStack::PopAndDestroy( scheduler );
+					//<QMail>
+CleanupStack::PopAndDestroy( 2, settings );
+					//</QMail>
 }
 // ignore in other states
 event = EEventNop;
 break;
 case EEventFetchMessages:
+NM_COMMENT("CIpsSosAOMBoxLogic: event: EEventFetchMessages");
 if ( ( iState == EStateWaitSyncStart ||
 iState == EStateIdleAndWaitCommands ) &&
 iFetchMsgArray.Count() > 0 )
 {
 iError = KErrNone;
 iAgent->StartFetchMessagesL( iFetchMsgArray );
 iFetchMsgArray.Reset();
+NM_COMMENT("CIpsSosAOMBoxLogic: switching state: EStateFetchOngoing");
 iState = EStateFetchOngoing;
 }
 else
 {
 // ignore event in other states
 iFetchMsgArray.Reset();
 }
 event = EEventNop;
 break;
 case EEventOperationCompleted:
+NM_COMMENT("CIpsSosAOMBoxLogic: event: EEventOperationCompleted");
 event = HandleOperationCompletionL();
 break;
 case EEventSuspendOperations:
+NM_COMMENT("CIpsSosAOMBoxLogic: event: EEventSuspendOperations");
 SuspendOperations();
 iState = EStateSuspended;
 event = EEventNop;
 break;
 case EEventContinueOperations:
+NM_COMMENT("CIpsSosAOMBoxLogic: event: EEventContinueOperations");
 if ( iState == EStateSuspended )
 {
+INFO_1("CIpsSosAOMBoxLogic: timer scheduled: %d", KIpsSosAOContinueWaitTime);
 iTimer->After( KIpsSosAOContinueWaitTime );
 }
-else
+event = EEventNop;
-{
-event = EEventNop;
-}
 // ignore if in other states
 break;
 case EEventStopAndRemoveOps:
+NM_COMMENT("CIpsSosAOMBoxLogic: event: EEventStopAndRemoveOps");
 // notify deletion
 iAgent->CancelAllAndDisconnectL();
 iTimer->Cancel();
+NM_COMMENT("CIpsSosAOMBoxLogic: switching state: EStateError");
 iState = EStateError;
 event = EEventNop;
 break;
 case EEventStart:
 default:
 CIpsSosAOBaseAgent::TAgentState agentState = iAgent->GetState();
 if ( iState == EStateSuspended &&
 ( agentState == CIpsSosAOBaseAgent::EStateConnectAndSyncOnHold ||
 agentState == CIpsSosAOBaseAgent::EStatePopulateOnHold ) )
 {
+iTimer->Cancel();
 iAgent->ContinueHoldOperations();
+NM_COMMENT("CIpsSosAOMBoxLogic: switching state: EStateSyncOngoing");
 iState = EStateSyncOngoing;
 }
 else if ( iState == EStateSuspended &&
 agentState == CIpsSosAOBaseAgent::EStateFetchOnHold )
 {
+iTimer->Cancel();
 iAgent->ContinueHoldOperations();
+NM_COMMENT("CIpsSosAOMBoxLogic: switching state: EStateFetchOngoing");
 iState = EStateFetchOngoing;
 }
 else
 {
 event = CheckSchedulingAndSwitchStateL();
 //
 TInt CIpsSosAOMBoxLogic::HandleOperationCompletionL()
 {
 FUNC_LOG;
 TInt event = EEventNop;
+	//<Qmail>
+CIpsSosAOSettingsHandler* settings =
+CIpsSosAOSettingsHandler::NewL(iSession, iMailboxId);
+CleanupStack::PushL(settings);
+	//</Qmail>
 if ( iState == EStateSyncOngoing )
 {
+INFO_1("CIpsSosAOMBoxLogic: operation completed error: %d", iError);
+bool doSaveSyncTime = EFalse;
 if ( !( iError == KErrNone || iError == KErrCancel ) )
 {
 ++iErrorCounter;
 }
 else
 {
+if (iError == KErrNone)
+{
+doSaveSyncTime = ETrue;
+}
 iError = KErrNone;
 iErrorCounter = 0;
 }
-//<cmail>
 if ( iError != KErrNone &&
 IsErrorFatalL( iError ) )
-//</cmail>
 {
 iAgent->CancelAllAndDisconnectL();
 // switch ao off
-iExtendedSettings->SetAlwaysOnlineState( EMailAoOff );
+			//<QMail>
+settings->SetAlwaysOnlineState( IpsServices::EMailAoOff );
 // emn not swithced of if its going to be "always on" in
 // future
-iExtendedSettings->SetEmnReceivedButNotSyncedFlag( EFalse );
-iDataApi->SaveExtendedSettingsL(
+settings->SetEmnReceivedButNotSyncedFlag( EFalse );
-*iExtendedSettings );
+//</QMail>
+NM_COMMENT("CIpsSosAOMBoxLogic: switching state: EStateError");
 iState = EStateError;
 iErrorCounter = 0;
 }
 else if ( iError != KErrNone &&
 iErrorCounter < KIpsSosAOMaxReTryTimes )
 {
 // not fatal error
-TIpsSetDataAoStates state = iExtendedSettings->AlwaysOnlineState();
+			//<QMail>
-if ( state == EMailAoOff )
+IpsServices::TIpsSetDataAoStates state =
+settings->AlwaysOnlineState();
+if ( state == IpsServices::EMailAoOff )
 {
+NM_COMMENT("CIpsSosAOMBoxLogic: switching state: EStateIdleAndWaitCommands");
 iState = EStateIdleAndWaitCommands;
 }
 else
 {
 if( !iTimer->IsActive() )
 {
-iTimer->After( KIpsSosAOReTryInterval );
+INFO_1("CIpsSosAOMBoxLogic: timer scheduled: %d", KIpsSosAOReTryInterval);
+iTimer->After( KIpsSosAOReTryInterval );
 }
+NM_COMMENT("CIpsSosAOMBoxLogic: switching state: EStateWaitSyncStart");
 iState = EStateWaitSyncStart;
 }
+			//</QMail>
 }
 else if ( iError != KErrNone &&
 iErrorCounter >= KIpsSosAOMaxReTryTimes )
 {
-//<cmail>
 SetEmnReceivedFlagL( EFalse );
-//</cmail>
 // not fatal, but all re trys are gone
 CalculateToNextIntervalL();
 }
 else
 {
 // no errors
 // update successfull sync time to settings
-SaveSuccessfulSyncTimeL();
+if (doSaveSyncTime)
+{
+SaveSuccessfulSyncTimeL();
+}
 // and adjust timer to sync interval
 CalculateToNextIntervalL();
 }
 }
 else if ( iState == EStateFetchOngoing )
 {
 iError = KErrNone;
 if ( iTimer->IsActive() )
 {
+NM_COMMENT("CIpsSosAOMBoxLogic: switching state: EStateWaitSyncStart");
 iState = EStateWaitSyncStart;
 }
 else
 {
 event = CheckSchedulingAndSwitchStateL();
 }
 }
+		//<Qmail>
+CleanupStack::PopAndDestroy(settings);
+	//</Qmail>
 return event;
 }
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 FUNC_LOG;
 if ( iState == EStateSyncOngoing || iState == EStateFetchOngoing )
 {
 iAgent->HoldOperations();
 }
-iState = EStateSuspended;
 // set suspend watchdog, if clien not continue this
 // ensure ao logic to continue
-if ( !iTimer->IsActive() )
+if ( !iTimer->IsActive() || iState == EStateSyncOngoing || iState == EStateFetchOngoing)
 {
+INFO_1("CIpsSosAOMBoxLogic: timer scheduled: %d", KIpsSosAOSuspendWatchdogTime);
 iTimer->After( KIpsSosAOSuspendWatchdogTime );
 }
-}
+NM_COMMENT("CIpsSosAOMBoxLogic: switching state: EStateSuspended");
+iState = EStateSuspended;
-// ----------------------------------------------------------------------------
+}
-// ----------------------------------------------------------------------------
-//
+// ----------------------------------------------------------------------------
-//<cmail>
+// ----------------------------------------------------------------------------
+//<QMail>
 TBool CIpsSosAOMBoxLogic::IsErrorFatalL( TInt aError )
-//</cmail>
 {
 FUNC_LOG;
 // error can be fatal only if we haven't got successful connect
 // in mailbox ever and error is something else than KErrNone or
 // KErrCancel, and retry interval is reached
 TBool ret = EFalse;
-LoadSettingsL();
+//<Qmail>
-TAOInfo info = iExtendedSettings->LastUpdateInfo();
+//</Qmail>
+CIpsSosAOSettingsHandler* settings =
+CIpsSosAOSettingsHandler::NewL(iSession, iMailboxId);
+CleanupStack::PushL(settings);
+IpsServices::TAOInfo info = settings->LastUpdateInfo();
 if ( aError != KErrNone && aError != KErrCancel
 && !info.iUpdateSuccessfulWithCurSettings
 && iErrorCounter >= KIpsSosAOMaxReTryTimes )
 {
 ret = ETrue;
 }
+CleanupStack::PopAndDestroy(settings);
+//</QMail>
 return ret;
 }
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 //
 CIpsSosAOMBoxLogic::TMBoxLogicEvent
 CIpsSosAOMBoxLogic::CheckSchedulingAndSwitchStateL()
 {
-//<cmail> logs removed </cmail>
+	//<Qmail>
+FUNC_LOG;
 iTimer->Cancel();
 TMBoxLogicEvent event = EEventNop;
 TTimeIntervalSeconds secondsToConnect = CalculateScheduledSyncTimeL();
-//<cmail> logs removed </cmail>
+CIpsSosAOSettingsHandler* settings =
+CIpsSosAOSettingsHandler::NewL(iSession, iMailboxId);
+CleanupStack::PushL(settings);
 if ( secondsToConnect.Int() == 0 )
 {
 //check last successfull sync time and check is interval reached
-TAOInfo info = iExtendedSettings->LastUpdateInfo();
+IpsServices::TAOInfo info = settings->LastUpdateInfo();
 if ( !info.iUpdateSuccessfulWithCurSettings )
 {
 event = EEventStartSync;
 }
 else
 {
 TTime now;
 now.HomeTime();
 TInt interval =
-iExtendedSettings->InboxRefreshTime() * KAOSecondsInMinute;
+settings->InboxRefreshTime() * KAOSecondsInMinute;
 TTimeIntervalSeconds secsFromLastSync;
 now.SecondsFrom( info.iLastSuccessfulUpdate, secsFromLastSync );
 if ( (secsFromLastSync.Int() > 0) && (
 secsFromLastSync.Int() < interval ) )
 {
 // adjust timer to correct sync time
-iTimer->After(interval - secsFromLastSync.Int());
+TInt syncAfter = interval - secsFromLastSync.Int();
+INFO_1("CIpsSosAOMBoxLogic: timer scheduled: %d", syncAfter);
+iTimer->After(syncAfter);
+NM_COMMENT("CIpsSosAOMBoxLogic: switching state: EStateWaitSyncStart");
 iState = EStateWaitSyncStart;
 }
 else
 {
 event = EEventStartSync;
 }
 }
 }
 else if ( secondsToConnect.Int() == KErrNotFound )
 {
 // means that ao is not on (but emn is)
+NM_COMMENT("CIpsSosAOMBoxLogic: switching state: EStateIdleAndWaitCommands");
 iState = EStateIdleAndWaitCommands;
-if ( iExtendedSettings->EmnReceivedButNotSyncedFlag() )
+if ( settings->EmnReceivedButNotSyncedFlag() )
 {
 // got emn when logic was stopped
 event = EEventStartSync;
 }
 }
 else
 {
+INFO_1("CIpsSosAOMBoxLogic: timer scheduled: %d", secondsToConnect);
 iTimer->After( secondsToConnect );
+NM_COMMENT("CIpsSosAOMBoxLogic: switching state: EStateWaitSyncStart");
 iState = EStateWaitSyncStart;
-}
+}
+CleanupStack::PopAndDestroy(settings);
+//</Qmail>
 return event;
 }
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 //
 void CIpsSosAOMBoxLogic::CalculateToNextIntervalL()
 {
 FUNC_LOG;
-//<cmail> logs removed </cmail>
 iTimer->Cancel();
 TTimeIntervalSeconds interval;
 // first check and calculate scheduling function also loads settings
 interval = CalculateScheduledSyncTimeL();
-//<cmail> logs removed </cmail>
 if ( interval.Int() == 0 )
 {
 // add next interval, if interval is grater than 0 it means
 // that off-line time is going, user have selected days / times from
 // settings
-iTimer->After(
-iExtendedSettings->InboxRefreshTime() * KAOSecondsInMinute );
+		//<QMail>
+CIpsSosAOSettingsHandler* settings =
+CIpsSosAOSettingsHandler::NewL(iSession, iMailboxId);
+CleanupStack::PushL(settings);
+TInt inboxRefreshTime = settings->InboxRefreshTime();
+TInt secs = inboxRefreshTime * KAOSecondsInMinute;
+INFO_1("CIpsSosAOMBoxLogic: inboxRefreshTime: %d", inboxRefreshTime);
+INFO_1("CIpsSosAOMBoxLogic: timer scheduled: %d", secs);
+if (secs > 0)
+{
+iTimer->After(TTimeIntervalSeconds(secs));
+}
+else
+{
+// panic at this point when we get zero time from settings
+__ASSERT_DEBUG( EFalse, User::Panic( KIpsSosAOPanicLit, KErrGeneral) );
+iTimer->After(TTimeIntervalSeconds(KAODefaultInboxSyncTimeSecs));
+}
+CleanupStack::PopAndDestroy(settings);
+	   //</QMail>
+NM_COMMENT("CIpsSosAOMBoxLogic: switching state: EStateWaitSyncStart");
 iState = EStateWaitSyncStart;
 }
 else if ( interval.Int() > 0 )
 {
+INFO_1("CIpsSosAOMBoxLogic: timer scheduled: %d", interval);
 iTimer->After( interval );
+NM_COMMENT("CIpsSosAOMBoxLogic: switching state: EStateWaitSyncStart");
 iState = EStateWaitSyncStart;
 }
 else
 {
+NM_COMMENT("CIpsSosAOMBoxLogic: switching state: EStateIdleAndWaitCommands");
 iState = EStateIdleAndWaitCommands;
 }
 }
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 //
 TTimeIntervalSeconds CIpsSosAOMBoxLogic::CalculateScheduledSyncTimeL()
 {
 FUNC_LOG;
-//<cmail> logs removed </cmail>
+	//<Qmail>
-LoadSettingsL();
-TTimeIntervalSeconds seconds;
+TTimeIntervalSeconds seconds=KErrNotFound;
+CIpsSosAOSettingsHandler* settings =
+CIpsSosAOSettingsHandler::NewL(iSession, iMailboxId);
+CleanupStack::PushL(settings);
 // first check is ao or emn on at all
-if ( (iExtendedSettings->AlwaysOnlineState() == EMailAoOff &&
+if ( (settings->AlwaysOnlineState() == IpsServices::EMailAoOff &&
-iExtendedSettings->EmailNotificationState() == EMailEmnOff  )||
+settings->EmailNotificationState() == IpsServices::EMailEmnOff  )||
-iExtendedSettings->SelectedWeekDays() == 0 ) // no week days chosen
+settings->SelectedWeekDays() == 0 ) // no week days chosen
 {
 // no timed sync on
+CleanupStack::PopAndDestroy(settings);
 return KErrNotFound;
 }
-if ( iExtendedSettings->EmailNotificationState() != EMailEmnOff &&
+if ( settings->EmailNotificationState() != IpsServices::EMailEmnOff &&
-!iExtendedSettings->EmnReceivedButNotSyncedFlag()   )
+!settings->EmnReceivedButNotSyncedFlag()   )
 {
+CleanupStack::PopAndDestroy(settings);
 return KErrNotFound;
 }
 CIpsSosAOSchedulerUtils* scheduler = CIpsSosAOSchedulerUtils::NewLC(
-*iExtendedSettings );
+*settings );
 TIpsSosAOConnectionType type = scheduler->SecondsToNextMark( seconds );
 if ( type == EAOCDisconnectAfter )
 {
 // if type is EAOCDisconnectAfter it means that scheduled days / times
 else
 {
 // this means that user have choosed time/day schedule at
 // timed sync and now we have to wait sync time
 }
-CleanupStack::PopAndDestroy( scheduler );
+CleanupStack::PopAndDestroy( 2, settings );
+	//</QMail>
 return seconds;
 }
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 //
 void CIpsSosAOMBoxLogic::LoadSettingsL()
 {
 FUNC_LOG;
-//<cmail> logs removed </cmail>
+//<QMail>
-delete iExtendedSettings;
+//removed loading
-iExtendedSettings = NULL;
+	//</QMail>
-iExtendedSettings = CIpsSetDataExtension::NewL();
-iDataApi->LoadExtendedSettingsL( iMailboxId, *iExtendedSettings );
-//<cmail> logs removed </cmail>
 }
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 //
 void CIpsSosAOMBoxLogic::SaveSuccessfulSyncTimeL()
 {
 FUNC_LOG;
 TTime now;
 now.HomeTime();
-LoadSettingsL();
+//<QMail>
-TAOInfo info;
+CIpsSosAOSettingsHandler* settings =
+CIpsSosAOSettingsHandler::NewL(iSession, iMailboxId);
+CleanupStack::PushL(settings);
+IpsServices::TAOInfo info;
 info.iLastSuccessfulUpdate = now;
 info.iUpdateSuccessfulWithCurSettings = ETrue;
-info.iLastUpdateFailed=EFalse;
+settings->SetLastUpdateInfo( info );
-iExtendedSettings->SetLastUpdateInfo( info );
 // clear flag
-iExtendedSettings->SetEmnReceivedButNotSyncedFlag( EFalse );
+settings->SetEmnReceivedButNotSyncedFlag( EFalse );
-iDataApi->SaveExtendedSettingsL(
-*iExtendedSettings );
+CleanupStack::PopAndDestroy(settings);
+	//</QMail>
 }
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 TBool CIpsSosAOMBoxLogic::CanConnectIfRoamingL()
 {
 FUNC_LOG;
-TBool ret = ETrue;
+TBool ret = EFalse;
+//<Qmail>
-RCmManager cmManager;
+RCmManager mgr;
-cmManager.OpenLC();
+CleanupClosePushL(mgr);
-TCmGenConnSettings OccSettings;
+TRAPD(err, mgr.OpenL());
-//ask roaming settings from occ
+TCmGenConnSettings set;
-cmManager.ReadGenConnSettingsL(OccSettings);
+if(err==KErrNone){
-if(OccSettings.iCellularDataUsageVisitor == ECmCellularDataUsageDisabled && iIsRoaming)
+TRAP(err, mgr.ReadGenConnSettingsL(set));
-{
+}
+CleanupStack::PopAndDestroy(&mgr);
+if( err==KErrNone &&
+set.iCellularDataUsageVisitor == ECmCellularDataUsageAutomatic){
+ret = ETrue;
+}
+else{
 ret = EFalse;
 }
-CleanupStack::PopAndDestroy(&cmManager); // cmManager
+//</QMail>
 return ret;
 }
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 TBool CIpsSosAOMBoxLogic::FirstEMNReceived()
 {
-return iExtendedSettings->FirstEmnReceived();
+	//<QMail>
+CIpsSosAOSettingsHandler* settings = NULL;
+TBool ret = EFalse;
+TRAP_IGNORE(CIpsSosAOSettingsHandler::NewL(iSession, iMailboxId));
+if(settings){
+ret = settings->FirstEmnReceived();
+delete settings;
+}
+return ret;
+	//</QMail>
 }
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 void CIpsSosAOMBoxLogic::SetFirstEMNReceived()
 {
-TRAP_IGNORE( LoadSettingsL() );
+//<QMail>
-iExtendedSettings->SetFirstEmnReceived( ETrue );
+CIpsSosAOSettingsHandler* settings = NULL;
-//if alwaysonline was allowed to roam, so will EMN be.
+TRAP_IGNORE( settings =
-iExtendedSettings->SetEmailNotificationState( EMailEmnAutomatic );
+CIpsSosAOSettingsHandler::NewL(iSession, iMailboxId));
+if(settings){
-// set always online state off when emn is on
+settings->SetFirstEmnReceived( ETrue );
-iExtendedSettings->SetAlwaysOnlineState( EMailAoOff );
-iExtendedSettings->SetInboxRefreshTime( KErrNotFound );
+//if alwaysonline was allowed to roam, so will EMN be.
-TRAP_IGNORE( iDataApi->SaveExtendedSettingsL(
+settings->SetEmailNotificationState(
-*iExtendedSettings ) );
+settings->AlwaysOnlineState() ==
+IpsServices::EMailAoAlways ?
-}
+IpsServices::EMailEmnAutomatic : IpsServices::EMailEmnHomeOnly );
-//<cmail> removing flags
-/*
-#ifdef IPSSOSIMAPPOLOGGING_ON
+// set always online state off when emn is on
-// ----------------------------------------------------------------------------
+settings->SetAlwaysOnlineState( IpsServices::EMailAoOff );
-// ----------------------------------------------------------------------------
+delete settings;
-//
+}
-void CIpsSosAOMBoxLogic::WriteDebugData( TInt aEvent )
-{
+	//</QMail>
-switch ( aEvent )
+}
-{
-case EEventTimerFired:
-break;
-case EEventStartSync:
-break;
-case EEventFetchMessages:
-break;
-case EEventOperationCompleted:
-break;
-case EEventSuspendOperations:
-break;
-case EEventContinueOperations:
-break;
-case EEventStart:
-break;
-case EEventStopAndRemoveOps:
-break;
-case EEventNop:
-break;
-default:
-break;
-}
-switch ( iState )
-{
-case EStateWaitSyncStart:
-break;
-case EStateSyncOngoing:
-break;
-case EStateFetchOngoing:
-break;
-case EStateSuspended:
-break;
-case EStateIdleAndWaitCommands:
-break;
-case EStateError:
-break;
-default:
-break;
-};
-}
-#endif // IPSSMTPLOGGING_ON*/
-//</cmail>
 // End of file

branch	RCL_3
changeset 63	d189ee25cf9d
parent 13	0396474f30f5
child 64	3533d4323edc