/*

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

*     Mms event watcher

*

*/

// INCLUDE FILES

#include    <msvapi.h>

#include    <msvids.h>

#include    <msvuids.h>

#include    <e32math.h>

#include    <apparc.h>

#include    <mtclreg.h>

#include    <bacntf.h>

#include    <centralrepository.h>

#include    <CoreApplicationUIsSDKCRKeys.h>

#include    <implementationproxy.h>

#include    "mmsconst.h"

#include    "mmsservercommon.h"

#include    "mmscmds.h"

#include    "mmswatcher.h"

#include    "watcher.h"

#include    "mmsclient.h"

#include    "mmserrors.h"

#include    "mmssettings.h" // for message variation directory

#include    "MmsEnginePrivateCRKeys.h"

#include    "mmscenrepobserver.h"

#include    "mmspollingtimer.h"

#include    "mmswatcherdebuglogging.h"

#include    "mmssettings.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

const TInt KPauseTime = 10 * KMmsMillion; // 10 s

const TInt KMmsMessageGranularity = 5;

const TInt KMmsStartDelay = 2 * KMmsMillion; // 2 s

const TInt KMmsMediaAvailableDelay = 3 * KMmsMillion; // 3 s

const TInt KMmsMessageVariationDelay = 5 * KMmsMillion; // 5 s

const TInt KMmsDiskFullPause = 300 * KMmsMillion; // 5 min

#ifdef __WINS__

const TInt KMmsDefaultPollingInterval = 3 * KMmsMillion; 

const TInt KMmsTidBuffer = 18;

const TInt KMmsRowBufferLength = 128;

#endif

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

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

//

// MmsWatcher is an ECOM plugin

//

const TImplementationProxy ImplementationTable[] = 

	{

	IMPLEMENTATION_PROXY_ENTRY(0x10005948, CMmsWatcher::NewL)

	};

EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)

	{

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

	return ImplementationTable;

	}

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

// Helper class constructor and destructor

CMmsPushEntry::CMmsPushEntry():

    iData( NULL ),

    iStatus( 0 ),

    iOperation( 0 )

    {

    }

CMmsPushEntry::~CMmsPushEntry()

    {

    delete iData;

    delete iOperation;

    }

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

// CMmsWatcher::CMmsWatcher

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

//

CMmsWatcher::CMmsWatcher(

    TInt aPriority,

    CWatcherLog& aLog)

    : CActive( aPriority ),

    iService( KMsvNullIndexEntryId ),

    iNotificationFolder( KMsvNullIndexEntryId ),

    iState( 0 ),

    iLog( aLog ),

    iLastError( KErrNone ),

    iSession( NULL ),

    iQueuedMessages( NULL ),

    iOperation( NULL )

    {

    CActiveScheduler::Add(this);

    }

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

// CMmsWatcher::ConstructL

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

//

void CMmsWatcher::ConstructL()

    {

    LOG(_L("ConstructL"));

    //

    // ConstructL basically creates some member objects and 

    // starts a couple of observers

    //

    iEvents = KMmsReasonBoot;

    iQueuedMessages = new(ELeave) CArrayPtrFlat<CMmsPushEntry>( KMmsMessageGranularity );

    iState = EStartup;

    iMediaAvailable = ETrue;

    iMmsVersion = KMmsDefaultVersion;

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

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

    // Offline state observer

    iOfflineObserver = CMmsCenRepObserver::NewL();

    iOfflineObserver->SubscribeNotification(

        KCRUidCoreApplicationUIs,

        KCoreAppUIsNetworkConnectionAllowed,

        this );

#ifdef __WINS__ // Support for localmode in WINS emulator

    iLocalModeIn = KMmsDefaultLocalModeDir;

    iPollingInterval = 0; 

    ReadLocalModeConfigData();

#endif

    // CEnvironmentChangeNotifier detects changes in system time.

    // This is needed to run garbage collection if the user moves

    // system time too much towards future.

    // Task scheduler can handle short changes, but if the change is a large one,

    // task scheduler does not reschedule the entry, and we must do it ourselves.

  	iNotifier = CEnvironmentChangeNotifier::NewL(

  	    CActive::EPriorityLow, 

  	    TCallBack( EnvironmentChanged, this ) );

	iNotifier->Start();

    //

    // NOTE: message server session is created just before used (in garbage 

    // collection). This ensures that MessageServer has properly booted.

    //

    // A little delay before any real actions in order to ensure everything

    // else is properly up and running.

    // iTimer cannot be active because it was just created

    iTimer.After( iStatus, KMmsStartDelay ); // 2 s - even this may be to much

    SetActive();

#ifndef _NO_MMSS_LOGGING_

    if ( IsActive() )

        {

        LOG(_L("MMS watcher is now active" ));

        }

    else

        {

        LOG(_L("MMS watcher is NOT active" ));

        }

#endif

    LOG(_L("End of ConstructL"));

    }

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

// CMmsWatcher::NewL

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

//

CMmsWatcher* CMmsWatcher::NewL( TAny* aWatcherParams )

    {

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

	CMmsWatcher* self = new (ELeave) CMmsWatcher( EPriorityStandard, params->iLog );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CMmsWatcher::~CMmsWatcher

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

//

CMmsWatcher::~CMmsWatcher()

    {

    //

    // Watchers should be running all the time

    // 

    LOG(_L("Destructor called"));

    Cancel();

    delete iOperation; // unfinished garbage collection...

    if ( iQueuedMessages )

        {

        iQueuedMessages->ResetAndDestroy();

        }

    delete iQueuedMessages;

    iTimer.Close();

    iFs.Close();

    delete iSession;

    delete iNotifier;

    delete iOfflineObserver;

#ifdef __WINS__ // Support for localmode polling in WINS emulator

    if( iPollingTimer )

        {

        delete iPollingTimer;

        }

#endif

    }

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

// CMmsWatcher::HandleCenRepNotificationL

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

//

void CMmsWatcher::HandleCenRepNotificationL(

    const TUid /*aRepositoryUid*/, // not needed currently because only one observer

    const TInt32 /*aKey*/,         // not needed currently because only one observer

    const TInt aValue )

    {

    // Offline state has changed.

    // If switch has been from offline to online -> invoke GarbageCollection

    LOG2(_L("Offline state: %d"), aValue );

    if( aValue != ECoreAppUIsNetworkConnectionAllowed )

        {

        // Now in offline -> nothing to do

        return;

        }

    else // back in online

        {

        iEvents |= KMmsReasonNetworkAllowed;

        TRequestStatus* status = &iStatus;

        if( iState != EStartup && iState != EMessageVariation )

            {

            iState = EGarbageCollection;

            }

        if( !IsActive() )

            {

            iStatus = KRequestPending;

            SetActive();

            User::RequestComplete( status, KErrNone );

            }

        }

    }

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

// CMmsWatcher::HandleSessionEventL

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

//

void CMmsWatcher::HandleSessionEventL(

    TMsvSessionEvent aEvent,

    TAny* aArg1,

    TAny* aArg2,

    TAny* /*aArg3*/)

    {

    // CMmsSession requires as a parameter a class that implements

    // session observer interface (this function). Therefore this

    // function must always exist, though it may return immediately

    // without doing anything.

    // This function is needed to watch events related to moving

    // the message store in systems where the message store can

    // be moved to a memory card.

    // For test purposes, we use this as a test callback.

    // This function is called every time an entry changes.

    // we check what happened, and if an entry appears in

    // sent folder, we know that it has been sent to MMSC, and

    // we try to fetch it back.

    if ( aEvent == EMsvGeneralError )

        {

        return;

        }

#ifdef __WINS__

    TMsvId parentId = KMsvNullIndexEntryId;

    if( aArg2 )

        {

        parentId = *(TMsvId*)aArg2;

        }

    CMsvEntrySelection* entries = NULL;

    if( aArg1 )

        {

        entries = STATIC_CAST(CMsvEntrySelection*, aArg1);

        }

#endif

    TRequestStatus* status = &iStatus;

#ifdef __WINS__

    TInt oldState = iState;

#endif

    switch (aEvent)

        {

        case EMsvCloseSession:

            LOG(_L("Session event EMsvCloseSession"));

            // fall through on purpose

        case EMsvServerTerminated:

            LOG(_L("Session event EMsvServerTerminated"));

            if ( iSession )

                {

                delete iSession;

                iSession = NULL;

                // if we have deleted the session, we get no more

                // events. We don't know when to restart.

                }

            break;

        case EMsvMediaChanged:

            {

            // MessageStore drive has changed.

            LOG(_L("Session event EMsvMediaChanged"));

            LOG3(_L("- from drive %d to drive %d"), *(TInt*) aArg1, *(TInt*) aArg2 );

            iMediaAvailable = ETrue;

            iMessageDrive = *(TInt*) aArg2;

            if( *(TInt*) aArg1 != *(TInt*) aArg2 )

                {

                iEvents |= KMmsReasonMessageStoreChanged;

                }

            // CenRep values for all entries must be updated

            // The ids of the MMS folders must be synchronized even if the drive has not changed

            // as we get this event when backup/restore happens, and in some case the restored

            // folder ids may be different from those in central repository (if restore is done

            // from a different phone or after phone has been flashed)

            GetMessagingEntriesL( ETrue );

            if( iEvents != 0 )

                {

                if ( iState != EStartup && iState != EMessageVariation )

                    {

                    iState = EGarbageCollection;

                    }

                if ( !IsActive() )

                    {

                    iStatus = KRequestPending;

                    SetActive();

                    User::RequestComplete( status, KErrNone );

                    }

                else

                    {

                    // if timer is running, cancel it because it is obvious

                    // that we have waited long enough and can start garbage

                    // collection now.

                    // Cancelling timer should bring us back to RunL()

                    LOG(_L("- already active, cancelling timer to speed up the process"));

                    iTimer.Cancel();

                    }

                }

            break;

            }

        case EMsvMediaUnavailable:

            {

            LOG(_L("Session event EMsvMediaUnavailable"));

            LOG2(_L("- Drive %d no longer available"), *(TInt*) aArg1 );

            iMediaAvailable = EFalse;

            if ( *(TInt*) aArg1 == iMessageDrive )

                {

                iMediaUnavailableTime.UniversalTime();

                }

            break;

            }

        case EMsvMediaAvailable:

            {

            LOG(_L("Session event EMsvMediaAvailable"));

            LOG2(_L("- Drive %d again available"), *(TInt*) aArg1 );

            // MessageStore has become available again. This could be due to

            // insertion of MMC card or after backup/restore operation 

            // has finished

            iMediaAvailable = ETrue;

            if ( !(iEvents & KMmsReasonMessageStoreChanged) )

                {

                iEvents |= KMmsReasonHotswap;

                iEvents |= KMmsReasonBackupEnded;

                }

            if( iState != EStartup && iState != EMessageVariation )

                {

                iState = EGarbageCollection;

                }

            if( !IsActive() )

                {

                // Delay here to prevent EMsvMediaAvailable from triggering

                // Garbage collection when message store is moved to another drive.

                // When message store is moved, the store is copied first.

                // After the copy is complete, we get EMsvMediaAvailable event,

                // but we must not start garbage collection on the original drive

                // because the message store is about to be changed.

                //

                // 3 s delay - we are cautious

                // if we are not active, timer cannot be running - no need to cancel

                iTimer.After( iStatus, KMmsMediaAvailableDelay ); 

                SetActive();

                }

            break;

            }

        case EMsvMediaIncorrect:

            {

            LOG(_L("Session event EMsvMediaIncorrect"));

            LOG2(_L("- Incorrect disk in drive %d"), *(TInt*) aArg1 );

            break;

            }

        case EMsvServerReady:

            {

            LOG(_L("Session event EMsvServerReady"));

            break;

            }

#ifdef __WINS__

        case EMsvEntriesCreated:

        case EMsvEntriesMoved:

            {

            // 

            // These events are relevant in Localmode only

            // 

            if ( parentId != KMsvSentEntryId )

                {

                // only sent items are interesting

                return;

                }

            // Get localmode setting from CenRep

            TBool localMode = EFalse;

            TInt retval = KErrNone;

            TRAP( retval, 

                {

                localMode = LocalModeL();

                });

            #ifndef _NO_MMSS_LOGGING_

            if( retval != KErrNone )

                {

                LOG(_L("ERROR connecting CenRep, defaulting to normal mode"));

                }

            #endif

            if( localMode == EFalse )

                {

                // Only localmode case is interesting

                return;

                }

            // Now invoke the server mtm to fetch it.

            // We queue the entry, set ourselves complete and

            // Let the RunL initiate the fetching.

            // We don't do anything unless the entry was MMS entry

            // Then get a list of files in MMSC directory, and

            // create notifications for them.

            // This will probably produce extra notifications,

            // but it is good to test that notifications about

            // unexisting messages or duplicates won't mess 

            // up the system.

            // Messages should be fetched one at a time, so that

            // there should not be too many conflicts.

            TInt notifications = 0;

            TInt size = 1;

            TEntry entry;

            TInt err = KErrNone;

            CDir* fileList = NULL;

            err = iFs.Entry( iLocalModeIn, entry );

            if ( err == KErrNone )

                {

                err = iFs.SetSessionPath( iLocalModeIn );

                TFindFile finder( iFs );

                _LIT( KWild, "*.mms" );

                if ( err == KErrNone )

                    {

                    err = finder.FindWildByPath( KWild, NULL, fileList );

                    }

                if ( err == KErrNone )

                    {

                    notifications = fileList->Count();

                    }

                TInt i;

                for (i = 0; i < notifications; i++ )

                    {

                    // generate notification from filename and file size

                    TParse fullEntry;

                    fullEntry.Set( ( ( *fileList )[i] ).iName, &iLocalModeIn, NULL );

                    TBuf8<KMaxFileName> buffer;

                    buffer.Copy( fullEntry.FullName() );

                    RFile file;

                    err = file.Open(iFs, fullEntry.FullName(), EFileShareAny );

                    if (err == KErrNone )

                        {

                        err = file.Size(size);

                        }

                    file.Close();

                    HBufC8 * notif = CreateNotificationL(buffer, size);

                    CleanupStack::PushL( notif );

                    TBool found = EFalse;

                    TInt i = 0;

                    while ( found == EFalse && i < iQueuedMessages->Count() ) 

                        {

                        if ( iQueuedMessages->At(i)->iData->Compare(*notif) == 0 )

                            {

                            found = ETrue;

                            }

                        i++;

                        }

                    if (! found )

                        {

                        CMmsPushEntry* newEntry = new( ELeave )CMmsPushEntry;