/*

* 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:  

*     CMsgErrorWatcher implementation file

*

*/

// INCLUDE FILES

#include <e32base.h>

#include <msvapi.h>

#include <msvids.h>          //Msv index entry ID's

#include <msvuids.h>

#include <mmscmds.h>         //EMmsScheduledReceiveForced

#include <mmsconst.h>        //Notification folder

#include <SenduiMtmUids.h>   //MTM Uids

#include <mtclreg.h>         //ClientMtmRegistry

#include <watcher.h>

#include <mmserrors.h>

#include <mmsclient.h>

#include <mmssettings.h>

#include <MsgErrorWatcherData.rsg>   // resouce identifiers

#include <avkon.rsg>            // resouce identifiers

#include <data_caging_path_literals.hrh> 

#include <avkon.hrh>

#include <AknGlobalNote.h>

#include <AknPhoneNumberGrouping.h>

#include <AknUtils.h>

#include <stringresourcereader.h>

#include <StringLoader.h>

#include <textresolver.h>

#include <in_iface.h>            // KErrIfAuthenticationFailure

#include <etelpckt.h>            // KErrGprsInsufficientResources, etc.

#include <exterror.h>            // KErrGsmMMServiceOptionTemporaryOutOfOrder

#include <gsmerror.h>

#include <centralrepository.h>    // link against centralrepository.lib

#include <messaginginternalcrkeys.h> // for Central Repository keys

#include <messagingvariant.hrh>  // Variation

#include "MsgErrorWatcher.h"

#include "MsgErrorWatcher.hrh"

#include "MsgSentItemsObserver.h"

#include "MsgErrorCommDbObserver.h"

#include "MsgCenRepObserver.h"

#include "MsgErrorConnectionObserver.h"

#include "MsgErrorDiskSpaceObserver.h"

#include "MsgErrorSmsDiskSpaceObserver.h"

#include "MsgErrorExtSmsDiskSpaceObserver.h"

#include "MsgErrorRoamingObserver.h"

#include "MsgErrorGlobalQuery.h"

#include "MsgErrorDisconnectDlg.h"

#include "MsgErrorStartupObserver.h"

#include "MsgLogsObserver.h"

#include "MsgGarbageCollection.h"

#include "MsgErrorWatcherLogging.h"

#include <implementationproxy.h>

// LOCAL CONSTANTS AND MACROS

_LIT( KMsgErrorWatcherResourceFileName, "msgerrorwatcherdata.rsc" );

const TUint KArrayGranularity = 5;

const TInt KDelayBetweenNotes = 2000000; //2 seconds

const TInt KDelayAfterDisconnect = 3000000; //3 seconds

const TInt KConnectionRetries = 3;

const TInt KIntMaxLength = 10; //2~32 =~ 4000000000

const TUint KInitialDelayBetweenSessionConnectRetries = 5000000; //five seconds

const TUint KMaxTimerRetries = 50;

//Total delay between first and last retry is

//( A * (B^2 + B) ) / 2

// - where A is KInitialDelayBetweenSessionConnectRetries

// -   and B is KMaxTimerRetries

//If A = 5 seconds and B = 50 times last retry is made

//after about 106 minutes from the first one.

const TMsvId KWatcherInboxFolderId = KMsvGlobalInBoxIndexEntryIdValue;

const TMsvId KWatcherOutboxFolderId = KMsvGlobalOutBoxIndexEntryIdValue;

const TUid KMessageEntryUid = { KUidMsvMessageEntryValue };

// This is more than what we need, but we are cautious

const TInt KExtraSpaceForDirectionalityMarkers = 6;

// ==================== LOCAL FUNCTIONS ====================

const TImplementationProxy ImplementationTable[] = 

	{

    IMPLEMENTATION_PROXY_ENTRY( 0x100059CF, CMsgErrorWatcher::NewL ) //lint !e611

	};

EXPORT_C const TImplementationProxy* ImplementationGroupProxy( TInt& aTableCount )

	{

	aTableCount = sizeof( ImplementationTable ) / sizeof( TImplementationProxy );

	return ImplementationTable;

	}

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

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

// CMsgErrorWatcher::CMsgErrorWatcher

//

// C++ constructor can NOT contain any code, that

// might leave.

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

//

CMsgErrorWatcher::CMsgErrorWatcher( RFs& aFs )

    : CActive( EPriorityStandard ),

    iMmsServiceId( KMsvNullIndexEntryId ),

    iNotificationFolderId( KMsvNullIndexEntryId ),

    iCurrentEntryId ( KMsvNullIndexEntryId ),

    iFs( aFs ) 

    {

    CActiveScheduler::Add( this );

    }

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

// CMsgErrorWatcher::ConstructL

//

// Symbian OS default constructor can leave.

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

//

void CMsgErrorWatcher::ConstructL()

    {

MEWLOGGER_ENTERFN( "ConstructL" );

    User::LeaveIfError( iTimer.CreateLocal() );

    TParse fileParse;

    fileParse.Set( KMsgErrorWatcherResourceFileName, &KDC_RESOURCE_FILES_DIR, NULL );

    TFileName resource( fileParse.FullName() );

    iResourceReader = CStringResourceReader::NewL( resource );

    TInt features = 0;   

    CRepository* repository = CRepository::NewL( KCRUidMuiuVariation );

    repository->Get( KMuiuMmsFeatures, features );

    delete repository;

    repository = NULL;

    if ( features & KMmsFeatureIdDelayDisconnectDialog )

        {

        iWatcherFlags |= EReceivingDisconnectDelay;

        }

    StartWatcherL();

MEWLOGGER_LEAVEFN( "ConstructL" );

    }

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

// CMsgErrorWatcher::NewL

//

// Two-phased constructor.

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

//

CMsgErrorWatcher* CMsgErrorWatcher::NewL( TAny* aWatcherParams )

    {

	TWatcherParams* params = reinterpret_cast<TWatcherParams*>( aWatcherParams );

    CMsgErrorWatcher* self = new ( ELeave ) CMsgErrorWatcher( params->iFs );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CMsgErrorWatcher::~CMsgErrorWatcher

//

// Destructor

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

//

CMsgErrorWatcher::~CMsgErrorWatcher()

    {

    StopWatcher();

    delete iResourceReader;

    iTimer.Close();

    }

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

// CMsgErrorWatcher::StartWatcherL

//

// Does the actual construction of the watcher.

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

//

void CMsgErrorWatcher::StartWatcherL()

    {

    MEWLOGGER_ENTERFN( "StartWatcherL" );

    iSession = CMsvSession::OpenSyncL( *this );

    iMmsReceiveErrorMessages = new ( ELeave ) CMsvEntrySelection;

    iMmsSendErrorMessages = new ( ELeave ) CMsvEntrySelection;

    iErrorMessages = new ( ELeave ) CMsvEntrySelection;

    iErrorMsgNotes = new ( ELeave ) CMsvEntrySelection;

    iNoteIds = new ( ELeave ) CArrayFixFlat<TInt>( KArrayGranularity );

    // Get message server session

    iClientMtmRegistry = CClientMtmRegistry::NewL( *iSession );

    TRAPD( err,

        {

        iMmsClient = static_cast<CMmsClientMtm*>

            ( iClientMtmRegistry->NewMtmL( KUidMsgTypeMultimedia ) );

        } );

    if ( err == KErrNotFound )

        {

        MEWLOGGER_WRITE( "MmsClientMtm not found!" );

        // Make sure iMmsClient is NULL - just in case.

        delete iMmsClient;

        iMmsClient = NULL;

        }

    else

        {

        User::LeaveIfError( err );

        }

    if ( iMmsClient )

        {

        // We're interested in roaming events only if MMS is enabled.

        iRoamingObserver = CMsgErrorRoamingObserver::NewL( this ); 

        }

    if ( iClientMtmRegistry->IsPresent( KSenduiMtmPushMtmUid ) )

        {

        iGarbageCollection = CMsgGarbageCollection::NewL( *iClientMtmRegistry );

        }

    iSentItemsObserver = CMsgSentItemsObserver::NewL( this, iSession );

    iStartupObserver = CMsgErrorStartupObserver::NewL( this );

    if(!( iWatcherFlags & EWatcherRunning))

        {

        //if not yet created

        iSmsDiskSpaceObserver = CMsgErrorSmsDiskSpaceObserver::NewL( this );

        iSmsExtDiskSpaceObserver = CMsgErrorExtSmsDiskSpaceObserver::NewL( this );

        }

    // If log database is corrupted, logs observer start leaves.

    // We ignore the leave, we can function otherwise, but we get no log events

    TRAP_IGNORE( iLogsObserver = CMsgLogsObserver::NewL( this, iFs ) );

    iWatcherFlags |= EWatcherRunning;

    if ( GetMmsServiceL() )

        {

        CheckMmsReceivingModeL();

        }

    InitMessageArraysL();

    // Startup successful if we got this far. Reset retry counter.

    iTimerRetries = 0;

    MEWLOGGER_LEAVEFN( "StartWatcherL" );

    }

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

// CMsgErrorWatcher::StopWatcher

//

// Stops (and destructs) the watcher.

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

//

void CMsgErrorWatcher::StopWatcher()

    {

    MEWLOGGER_ENTERFN( "StopWatcher" );

    iWatcherFlags &= ~EWatcherRunning;

    iWatcherFlags &= ~ENoAPErrorPending;

    iMmsServiceId = KMsvNullIndexEntryId;

    iNotificationFolderId = KMsvNullIndexEntryId;

    Cancel();

    delete iGarbageCollection;

    iGarbageCollection = NULL;

    delete iLogsObserver;

    iLogsObserver = NULL;

    delete iCommDbObserver;

    iCommDbObserver = NULL;

    delete iCenRepObserver;

    iCenRepObserver = NULL;

    delete iConnectionObserver;

    iConnectionObserver = NULL;

    delete iDiskSpaceObserver;

    iDiskSpaceObserver = NULL;

    delete iSmsDiskSpaceObserver;

    iSmsDiskSpaceObserver = NULL;

    delete iSmsExtDiskSpaceObserver;

    iSmsExtDiskSpaceObserver = NULL;    

    delete iRoamingObserver;

    iRoamingObserver = NULL;

    delete iMmsClient;

    iMmsClient = NULL;

    delete iClientMtmRegistry;

    iClientMtmRegistry = NULL;

    delete iOperation;

    iOperation = NULL;

    delete iSentItemsObserver;

    iSentItemsObserver = NULL;

    delete iStartupObserver;

    iStartupObserver = NULL;

    delete iSession;

    iSession = NULL;

    delete iMmsReceiveErrorMessages;

    iMmsReceiveErrorMessages = NULL;

    delete iMmsSendErrorMessages;

    iMmsSendErrorMessages = NULL;

    delete iNoteIds;

    iNoteIds = NULL;

    delete iErrorMsgText;

    iErrorMsgText = NULL;

    delete iErrorMsgDetails;

    iErrorMsgDetails = NULL;

    delete iErrorQuery;

    iErrorQuery = NULL;

    delete iDisconnectQuery;

    iDisconnectQuery = NULL;

    delete iDisconnectDlg;

    iDisconnectDlg = NULL;

    delete iErrorMsgNotes;

    iErrorMsgNotes = NULL;

    delete iErrorMessages;

    iErrorMessages = NULL;

    MEWLOGGER_LEAVEFN( "StopWatcher" );

    }

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

// CMsgErrorWatcher::StartRestartTimer

//

// Start session reconnect timer.

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

//

void CMsgErrorWatcher::StartRestartTimer()

    {

    if ( !IsActive() ) 

        {

    MEWLOGGER_WRITE( "Starting timer" );

        iStatus = KRequestPending;

        iRequestType = EMsgRequestStartingUp;

        iTimerRetries++;

        //The interval between retries comes longer every time

        iTimer.After( iStatus,

            iTimerRetries * KInitialDelayBetweenSessionConnectRetries );

        SetActive();

        }

    }

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

// CMsgErrorWatcher::InitMessageArraysL

//

// Initialise arrays

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

//

void CMsgErrorWatcher::InitMessageArraysL()

    {

    MEWLOGGER_ENTERFN( "InitMessageArraysL" );

    CMsvEntry* outbox = iSession->GetEntryL( KWatcherOutboxFolderId );

    CleanupStack::PushL( outbox );

    CMsvEntrySelection* outboxMessages =

        outbox->ChildrenWithTypeL( KMessageEntryUid );

    CleanupStack::PushL( outboxMessages );

    TInt count = outboxMessages->Count();

    while ( count-- )

        {

        TMsvId dummy;

        TMsvEntry entry;

        TInt error = iSession->GetEntry(

            outboxMessages->At( count ), dummy, entry );

        TUid mtm = entry.iMtm;

        if ( !error &&

            ( mtm == KSenduiMtmSmsUid ||

            mtm == KSenduiMtmMmsUid  ||

            mtm == KSenduiMtmSmtpUid ||

            mtm == KUidMsgMMSNotification ) )

            {

            iErrorMessages->AppendL( entry.Id() );

            MEWLOGGER_ENTERFN( "Send msg added" );

            }

        }

    CleanupStack::PopAndDestroy( outboxMessages );  

    CleanupStack::PopAndDestroy( outbox );

    }

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

// CMsgErrorWatcher::ResetWatcher

//

// Resets watcher.

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

//

void CMsgErrorWatcher::ResetWatcher()

    {

    MEWLOGGER_ENTERFN( "ResetWatcher" );

    iWatcherFlags &= ~ENoAPErrorPending;

    //Drop all observers

    delete iCommDbObserver;

    iCommDbObserver = NULL;

    delete iCenRepObserver;

    iCenRepObserver = NULL;

    delete iConnectionObserver;

    iConnectionObserver = NULL;

    delete iDiskSpaceObserver;

    iDiskSpaceObserver = NULL;

	delete iSmsDiskSpaceObserver;

    iSmsDiskSpaceObserver = NULL;

    delete iSmsExtDiskSpaceObserver;

    iSmsExtDiskSpaceObserver = NULL;    

    //Reset disk space errors

    iDiskSpaceErrors = 0;

    }

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

// CMsgErrorWatcher::GetMmsServiceL

//

// Retrieves MMS service id from MsgStore

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

//

TBool CMsgErrorWatcher::GetMmsServiceL()

    {

    if ( !iMmsClient )

        {

        return EFalse;

        }

    if ( iMmsServiceId == KMsvNullIndexEntryId )

        {

        MEWLOGGER_WRITE( "Looking for MMS service" );

        iMmsClient->RestoreSettingsL();

        iMmsServiceId = iMmsClient->MmsSettings().Service();

        iNotificationFolderId = iMmsClient->MmsSettings().NotificationFolder();

        iMaxReceiveSize = iMmsClient->MmsSettings().MaximumReceiveSize();

        }

    return ( iMmsServiceId != KMsvNullIndexEntryId );

    }

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

// CMsgErrorWatcher::StartMmsFetchL

//

// Initiates MMS fetch

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

//

void CMsgErrorWatcher::StartMmsFetchL()

    {

    MEWLOGGER_ENTERFN( "StartMmsFetchL" );

    if ( !IsActive() && iMmsReceiveErrorMessages->Count() )

        {

        MEWLOGGER_WRITEF( _L("Fetching %d message(s)"),

            iMmsReceiveErrorMessages->Count() );

        CancelNotesL();

        TCommandParameters parameters; // initialized to zero

        TCommandParametersBuf paramPack( parameters );

        //Add service entry as the first entry in the array

        iMmsReceiveErrorMessages->InsertL( 0, iMmsServiceId );

        // First remove existing schedules:

        MEWLOGGER_WRITE( "Deleting old schedules" );

        // Calling synchronous TransferCommandL method

        const TInt KBufSize = 256;

        TBuf8<KBufSize> dummy;

        iSession->TransferCommandL( *iMmsReceiveErrorMessages,

            EMmsDeleteSchedule,

            paramPack,

            dummy );

        MEWLOGGER_WRITE( "Old schedules deleted!" );

        // Then reschedule:

        iStatus = KRequestPending;

        iRequestType = EMsgRequestFetching;

        delete iOperation;

        iOperation = NULL;

        MEWLOGGER_WRITE( "Request fetch" );

        iOperation = iSession->TransferCommandL( *iMmsReceiveErrorMessages,

            EMmsScheduledReceive,

            paramPack,

            iStatus );

        SetActive();

        MEWLOGGER_WRITE( "Reset array" );

        iMmsReceiveErrorMessages->Reset();

        }

    }

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

// CMsgErrorWatcher::StartMmsSendL

//

// Initiates MMS fetch

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

//

void CMsgErrorWatcher::StartMmsSendL()

    {

    MEWLOGGER_ENTERFN( "StartMmsSendL" );

    if ( !IsActive() && iMmsSendErrorMessages->Count() )

        {

        MEWLOGGER_WRITEF( _L("Sending %d message(s)"),

            iMmsSendErrorMessages->Count() );

        CancelNotesL();

        TCommandParameters parameters; // initialized to zero

        TCommandParametersBuf paramPack( parameters );

        //Add service entry as the first entry in the array

        iMmsSendErrorMessages->InsertL( 0, iMmsServiceId );

        iStatus = KRequestPending;

        iRequestType = EMsgRequestSending;

        delete iOperation;

        iOperation = NULL;

        MEWLOGGER_WRITE( "Request send" );

        iOperation = iSession->TransferCommandL( *iMmsSendErrorMessages,

            EMmsScheduledSend,

            paramPack,

            iStatus );

        SetActive();

        MEWLOGGER_WRITE( "Reset array" );

        iMmsSendErrorMessages->Reset();

        }

    }

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

// CMsgErrorWatcher::CheckMmsReceivingModeL

//