/*

* Copyright (c) 2010 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:  

*     CMsgErrorWatcherPrivate 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 <xqconversions.h>

#include <hbglobal.h>

#include <HbTranslator>

#include <QString>

#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_p.h"

#include "msgerrorwatcher.hrh"

#include "msgerrorcommdbobserver.h"

#include "msgcenrepobserver.h"

// this should be handled later,

//#include "msgerrorconnectionobserver.h"

#include "msgerrordiskspaceobserver.h"

#include "msgerrorsmsdiskspaceobserver.h"

#include "msgerrorextsmsdiskspaceobserver.h"

#include "msgerrorroamingobserver.h"

#include "msgerrorstartupobserver.h"

#include "debugtraces.h"

//const TInt KConnectionRetries = 3;

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

const TUint KInitialDelayBetweenSessionConnectRetries = 5000000; //five seconds

const TUint KMaxTimerRetries = 50;

//const TInt KDelayAfterDisconnect = 3000000; //3 seconds

//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 };

CMsgErrorWatcherPrivate::CMsgErrorWatcherPrivate(MsgErrorWatcher* msgErrorWatcher  ): 

CActive( EPriorityStandard ),

    q_ptr(msgErrorWatcher),

    iMmsServiceId( KMsvNullIndexEntryId ),

    iNotificationFolderId( KMsvNullIndexEntryId ),

    iCurrentEntryId ( KMsvNullIndexEntryId )

    {

    QDEBUG_WRITE("CMsgErrorWatcherPrivate:CMsgErrorWatcherPrivate : Enter");

    CActiveScheduler::Add( this );

    TRAP_IGNORE(InitL())

    QDEBUG_WRITE("CMsgErrorWatcherPrivate:CMsgErrorWatcherPrivate : Exit");

    }

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

// CMsgErrorWatcherPrivate::CMsgErrorWatcherPrivate

//

// Symbian OS default constructor can leave.

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

//

void CMsgErrorWatcherPrivate::InitL()

    {

    QDEBUG_WRITE("CMsgErrorWatcherPrivate:InitL : Enter");

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

    User::LeaveIfError(iFs.Connect());

    TInt features = 0;   

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

    repository->Get( KMuiuMmsFeatures, features );

    delete repository;

    repository = NULL;

    if ( features & KMmsFeatureIdDelayDisconnectDialog )

        {

        iWatcherFlags |= EReceivingDisconnectDelay;

        }

    StartWatcherL();

    QDEBUG_WRITE("CMsgErrorWatcherPrivate:InitL : Exit");

    }

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

// CMsgErrorWatcherPrivate::~CMsgErrorWatcherPrivate

//

// Destructor

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

//

CMsgErrorWatcherPrivate::~CMsgErrorWatcherPrivate()

    {

    QDEBUG_WRITE("CMsgErrorWatcherPrivate:~CMsgErrorWatcherPrivate : Enter");   

    StopWatcher();

    iTimer.Close();

    QDEBUG_WRITE("CMsgErrorWatcherPrivate:~CMsgErrorWatcherPrivate : Exit");  

    }

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

// CMsgErrorWatcherPrivate::StartWatcherL

//

// Does the actual construction of the watcher.

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

//

void CMsgErrorWatcherPrivate::StartWatcherL()

    {

    QDEBUG_WRITE("CMsgErrorWatcherPrivate:StartMmsFetchL : Enter"); 

    iSession = CMsvSession::OpenSyncL( *this );

    // might be required in future for propogating the errors to the ui.

    iMmsReceiveErrorMessages = new ( ELeave ) CMsvEntrySelection;

    iMmsSendErrorMessages = new ( ELeave ) CMsvEntrySelection;

    // Get message server session

    iClientMtmRegistry = CClientMtmRegistry::NewL( *iSession );

    TRAPD( err,

        {

        iMmsClient = static_cast<CMmsClientMtm*>

            ( iClientMtmRegistry->NewMtmL( KUidMsgTypeMultimedia ) );

        } );

    if ( err == KErrNotFound )

        {

        QDEBUG_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 ); 

        QDEBUG_WRITE( "Created Roaming Observer!" );

        }

    iStartupObserver = CMsgErrorStartupObserver::NewL( *this );

    if(!( iWatcherFlags & EWatcherRunning))

        {

        //if not yet created

        iSmsDiskSpaceObserver = CMsgErrorSmsDiskSpaceObserver::NewL( *this );

        iSmsExtDiskSpaceObserver = CMsgErrorExtSmsDiskSpaceObserver::NewL( *this );

        QDEBUG_WRITE( "Created iSmsDiskSpaceObserver, iSmsExtDiskSpaceObserver!" );

        }

    iWatcherFlags |= EWatcherRunning;

    if ( GetMmsServiceL() )

        {

        CheckMmsReceivingModeL();

        }

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

    iTimerRetries = 0;

    QDEBUG_WRITE("CMsgErrorWatcherPrivate:StartWatcherL : Exit");

    }

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

// CMsgErrorWatcherPrivate::StopWatcher

//

// Stops (and destructs) the watcher.

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

//

void CMsgErrorWatcherPrivate::StopWatcher()

    {

    QDEBUG_WRITE("CMsgErrorWatcherPrivate:~CMsgErrorWatcherPrivate : Enter");

    iWatcherFlags &= ~EWatcherRunning;

    iWatcherFlags &= ~ENoAPErrorPending;

    iMmsServiceId = KMsvNullIndexEntryId;

    iNotificationFolderId = KMsvNullIndexEntryId;

    Cancel();

    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 iStartupObserver;

    iStartupObserver = NULL;

    delete iSession;

    iSession = NULL;

    delete iMmsReceiveErrorMessages;

    iMmsReceiveErrorMessages = NULL;

    delete iMmsSendErrorMessages;

    iMmsSendErrorMessages = NULL;

    QDEBUG_WRITE("CMsgErrorWatcherPrivate:~CMsgErrorWatcherPrivate : Exit");

    }

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

// CMsgErrorWatcherPrivate::StartRestartTimer

//

// Start session reconnect timer.

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

//

void CMsgErrorWatcherPrivate::StartRestartTimer()

    {

    QDEBUG_WRITE("CMsgErrorWatcherPrivate:~CMsgErrorWatcherPrivate : Enter");

    if ( !IsActive() ) 

        {

        QDEBUG_WRITE( "Starting timer" );

        iStatus = KRequestPending;

        iRequestType = EMsgRequestStartingUp;

        iTimerRetries++;

        //The interval between retries comes longer every time

        iTimer.After( iStatus,

            iTimerRetries * KInitialDelayBetweenSessionConnectRetries );

        SetActive();

        }

    QDEBUG_WRITE("CMsgErrorWatcherPrivate:~CMsgErrorWatcherPrivate : Exit");

    }

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

// CMsgErrorWatcherPrivate::ResetWatcher

//

// Resets watcher.

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

//

void CMsgErrorWatcherPrivate::ResetWatcher()

    {

    QDEBUG_WRITE("CMsgErrorWatcherPrivate:~CMsgErrorWatcherPrivate : Enter");

    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;

    QDEBUG_WRITE("CMsgErrorWatcherPrivate:~CMsgErrorWatcherPrivate : Exit");

    }

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

// CMsgErrorWatcherPrivate::GetMmsServiceL

//

// Retrieves MMS service id from MsgStore

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

//

TBool CMsgErrorWatcherPrivate::GetMmsServiceL()

    {

    if ( !iMmsClient )

        {

        return EFalse;

        }

    QDEBUG_WRITE("CMsgErrorWatcherPrivate:~CMsgErrorWatcherPrivate : Enter");

    if ( iMmsServiceId == KMsvNullIndexEntryId )

        {

        QDEBUG_WRITE( "Looking for MMS service" );

        iMmsClient->RestoreSettingsL();

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

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

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

        }

    QDEBUG_WRITE("CMsgErrorWatcherPrivate:~CMsgErrorWatcherPrivate : Exit");

    return ( iMmsServiceId != KMsvNullIndexEntryId );

    }

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

// CMsgErrorWatcherPrivate::StartMmsFetchL

//

// Initiates MMS fetch

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

//

void CMsgErrorWatcherPrivate::StartMmsFetchL()

    {

    QDEBUG_WRITE("CMsgErrorWatcherPrivate:~CMsgErrorWatcherPrivate : Enter");

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

        {

        QDEBUG_WRITE_FORMAT("Fetching  message(s): ",

            iMmsReceiveErrorMessages->Count() );

        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:

        QDEBUG_WRITE( "Deleting old schedules" );

        // Calling synchronous TransferCommandL method

        const TInt KBufSize = 256;

        TBuf8<KBufSize> dummy;

        iSession->TransferCommandL( *iMmsReceiveErrorMessages,

            EMmsDeleteSchedule,

            paramPack,

            dummy );

        QDEBUG_WRITE( "Old schedules deleted!" );

        // Then reschedule:

        iStatus = KRequestPending;

        iRequestType = EMsgRequestFetching;

        delete iOperation;

        iOperation = NULL;

        QDEBUG_WRITE( "Request fetch" );

        iOperation = iSession->TransferCommandL( *iMmsReceiveErrorMessages,

            EMmsScheduledReceive,

            paramPack,

            iStatus );

        SetActive();

        QDEBUG_WRITE( "Reset array" );

        iMmsReceiveErrorMessages->Reset();

        }

    QDEBUG_WRITE("CMsgErrorWatcherPrivate:~CMsgErrorWatcherPrivate : Exit");

    }

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

// CMsgErrorWatcherPrivate::StartMmsSendL

//

// 

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

// TODO: to be handled late when connection errors are handled.

//void CMsgErrorWatcherPrivate::StartMmsSendL()

//    {

//   QDEBUG_WRITE("CMsgErrorWatcherPrivate:StartMmsSendL : Enter");

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

//        {

//        QDEBUG_WRITE_FORMAT("Sending message(s): "),

//            iMmsSendErrorMessages->Count() );

//        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;

//        QDEBUG_WRITE( "Request send" );

//        iOperation = iSession->TransferCommandL( *iMmsSendErrorMessages,

//            EMmsScheduledSend,

//            paramPack,

//            iStatus );

//        SetActive();

//        QDEBUG_WRITE( "Reset array" );

//        iMmsSendErrorMessages->Reset();

//        }

//     QDEBUG_WRITE("CMsgErrorWatcherPrivate:StartMmsSendL : Exit");

//    }

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

// CMsgErrorWatcherPrivate::CheckMmsReceivingModeL

//

// Checks MMS receiving mode

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

//

void CMsgErrorWatcherPrivate::CheckMmsReceivingModeL()

    {

    if ( !( iWatcherFlags & EStartupReady ) || !GetMmsServiceL() )

        {

        return;

        }

    QDEBUG_WRITE("CMsgErrorWatcherPrivate:CMsgErrorWatcherPrivate : Enter");

    TBool validAP = ValidateMmsServiceL(); //Refreshes MMS settings

    TInt fetchHome = iMmsClient->MmsSettings().ReceivingModeHome();

    TInt fetchRoam = iMmsClient->MmsSettings().ReceivingModeForeign();

    QDEBUG_WRITE_FORMAT("ReceivingModeHome: ", fetchHome );

    QDEBUG_WRITE_FORMAT("ReceivingModeForeign: ", fetchRoam );

    if ( validAP &&

        fetchRoam == EMmsReceivingReject &&

        fetchHome != EMmsReceivingReject )

        {

        QDEBUG_WRITE( "ShowNote flag enabled" );

        iWatcherFlags |= EShowRoamingNote;

        }

    else

        {

        //Reset roaming note flag

        QDEBUG_WRITE( "ShowNote flag disabled" );

        iWatcherFlags &= ~EShowRoamingNote;

        iWatcherFlags &= ~ERoamingNoteShown;

        }

    QDEBUG_WRITE("CMsgErrorWatcherPrivate:~CMsgErrorWatcherPrivate : Exit");

    }

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

// CMsgErrorWatcherPrivate::ValidateMmsServiceL

//

// Validates MMS service

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

//

TBool CMsgErrorWatcherPrivate::ValidateMmsServiceL()

    {

//    if ( !GetMmsServiceL() )

//        {

//        return EFalse;

//        }

    QDEBUG_WRITE("CMsgErrorWatcherPrivate:ValidateMmsServiceL : Enter");

    iMmsClient->RestoreSettingsL(); //Refreshes MMS settings

    QDEBUG_WRITE_FORMAT("ValidateService: ", iMmsClient->ValidateService( iMmsServiceId ) );

    TInt errorCode = iMmsClient->ValidateService( iMmsServiceId );

    QDEBUG_WRITE_FORMAT("ValidateService: errorcode ---  ", errorCode );

    QDEBUG_WRITE("CMsgErrorWatcherPrivate:ValidateMmsServiceL : Exit");

    return ( errorCode == KErrNone );

    }

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

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

// CMsgErrorWatcherPrivate::HandleNoAPErrorL

//

// Handles "no access point defined" error

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

//

void CMsgErrorWatcherPrivate::HandleNoAPErrorL( TMsvEntry& aEntry )

    { 

    QDEBUG_WRITE("CMsgErrorWatcherPrivate:HandleNoAPErrorL : Enter");

    iMmsReceiveErrorMessages->AppendL( aEntry.Id() );

    iWatcherFlags |= ENoAPErrorPending;

    if ( !iCenRepObserver )

        {

        QDEBUG_WRITE( "Creating CenRep observer" );

        iCenRepObserver = CMsgCenRepObserver::NewL( *this );

        iCenRepObserver->SubscribeNotification();

        }

    //Let's reset the TMsvEntry::iError to get rig of excess warning note

    ResetErrorFieldL( aEntry );

    QDEBUG_WRITE("CMsgErrorWatcherPrivate:HandleNoAPErrorL : Exit");

    }

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

// CMsgErrorWatcherPrivate::HandleInvalidAPErrorL

//

// Handles "invalid access point" error

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

//

void CMsgErrorWatcherPrivate::HandleInvalidAPErrorL( TMsvEntry& aEntry, TBool aStartObserver )

    {

    QDEBUG_WRITE("CMsgErrorWatcherPrivate:HandleInvalidAPErrorL : Enter");

    iMmsReceiveErrorMessages->AppendL( aEntry.Id() );

    q_ptr->ShowNote(EInvalidAccessPointNote);

    if ( aStartObserver && !iCommDbObserver )

        {

        QDEBUG_WRITE( "Creating CommDB observer" );

        iCommDbObserver = CMsgErrorCommDbObserver::NewL( *this );

        }

    if ( aStartObserver && !iCenRepObserver )

        {

        //We must also start cenrep observer

        QDEBUG_WRITE( "Creating CenRep observer" );

        iCenRepObserver = CMsgCenRepObserver::NewL( *this );

        iCenRepObserver->SubscribeNotification();

        }    

    //Let's reset the TMsvEntry::iError to get rig of excess warning note

    ResetErrorFieldL( aEntry ); 

    QDEBUG_WRITE("CMsgErrorWatcherPrivate:HandleInvalidAPErrorL : Exit");

    }

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

// CMsgErrorWatcherPrivate::HandleConnectionErrorL

//