/*

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

*     A Client MTM to access MMS notifications in a manual fetch mode.

*     All this is needed to support new mtm type for Symbian OS messaging

*     UI components.

*

*/

// INCLUDE FILES

#include <msvids.h>

#include "mmsheaders.h"

#include "mmsnotificationclient.h"

#include "mmscmds.h"

#include "mmsmessageoperation.h"

#include "mmsmmboxviewheaders.h"

#include "mmssettings.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

const TInt KMmsAttributeArrayGranularity = 8;

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

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

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

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

// CMmsClientNotificationMtm::NewL

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

//

EXPORT_C CMmsNotificationClientMtm* CMmsNotificationClientMtm::NewL(

    CRegisteredMtmDll& aRegisteredMtmDll,

    CMsvSession& aSession )

    {

    CMmsNotificationClientMtm* self = new ( ELeave ) CMmsNotificationClientMtm(

        aRegisteredMtmDll, aSession );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CMmsClientNotificationMtm::CMmsNotificationClientMtm

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

//

CMmsNotificationClientMtm::CMmsNotificationClientMtm(

    CRegisteredMtmDll& aRegisteredMtmDll,

    CMsvSession& aSession )

    : CMmsClientMtm( aRegisteredMtmDll, aSession )

    {

    __ASSERT_DEBUG( Type() == KUidMsgMMSNotification, gPanic( EMmsBadMtmTypeUid ) );

    }

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

// CMmsClientNotificationMtm::~CMmsNotificationClientMtm

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

//

CMmsNotificationClientMtm::~CMmsNotificationClientMtm()

    {

    }

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

// CMmsClientNotificationMtm::ConstructL

// 

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

//

void CMmsNotificationClientMtm::ConstructL()

    {

    // First loading settings

    iMmsSettings = CMmsSettings::NewL();

    iMmsSettings->LoadSettingsL();

    // Get the base values to detect changes

    iHomeMode = iMmsSettings->ReceivingModeHome();

    iRoamingMode = iMmsSettings->ReceivingModeForeign();

    iAccessPointCount = iMmsSettings->AccessPointCount();

    iMessageDrive = EDriveC;

    TInt error = KErrNone;

    TRAP ( error, { iMessageDrive = Session().CurrentDriveL(); } );

    if ( error != KErrNone )

        {

        // if cannot ask, use default

        iMessageDrive = EDriveC;

        }

    // Notification client mtm does not create new service

    iServiceId = iMmsSettings->Service();

    iMmsHeaders = CMmsHeaders::NewL( iMmsSettings->MmsVersion() );

    iAttributes  = new( ELeave ) CDesCArrayFlat( KMmsAttributeArrayGranularity );

    // Set the original context to the service entry

    SwitchCurrentEntryL( iServiceId );

    }

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

// CMmsClientMtm::QueryCapability

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

//

TInt CMmsNotificationClientMtm::QueryCapability(

    TUid /*aCapability*/,

    TInt& /*aResponse*/ )

    {

    // Nothing Supported at the moment

    return KErrNotSupported;

    }

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

// CMmsNotificationClientMtm::ForwardL

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

//

CMsvOperation* CMmsNotificationClientMtm::ForwardL(

    TMsvId aDestination,

    TMsvPartList /*aPartList*/,

    TRequestStatus& aCompletionStatus )

    {

    //

    // Actual creation is done synchronously below

    //

    TMsvId id = CreateForwardEntryL( aDestination );

    //

    // This method has to be asynchronous..

    //

    TPckgC < TMsvId > progress = id;

    return  CMsvCompletedOperation::NewL( Session(), Type(), progress, 

        KMsvLocalServiceIndexEntryId, aCompletionStatus );

    }

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

// CMmsClientNotificationMtm::CreateForwardEntryL

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

//

TMsvId CMmsNotificationClientMtm::CreateForwardEntryL( TMsvId aDestination )

    {

    //

    // Check that current context is valid

    //

    if( iMsvEntry->Entry().iType != KUidMsvMessageEntry

        || iMsvEntry->Entry().iMtm != KUidMsgMMSNotification )

        {

        User::Leave( KErrUnknown );

        }

    // It is assumed that a created forward entry can not be saved to drafts.

    // I.e. the application calling this, is responsible to take care that

    // the entry is either SENT or DESTROYED.

    //

    // Load entry to local cache if necessary

    //

    if( iMmsHeaders->ContentLocation() == TPtrC8() )

        {

        LoadMessageL();

        }

    //

    // Create new Mms message object into aDestination folder

    //

    TMsvId forwardId = CMmsMessageOperation::CreateForwardWithoutRetrievalL(

        Session(),

        *iMmsHeaders,

        iMsvEntry->EntryId(),

        aDestination,

        iServiceId );

    return forwardId;

    }

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

// CMmsClientNotificationMtm::SendL

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

//

CMsvOperation* CMmsNotificationClientMtm::SendL( 

    TRequestStatus& aCompletionStatus,

    const TTime aSendingTime )

    {

    //

    // Is it possible to proceed with the operation...

    // If yes, the notification is marked as "further-operations-not-allowed"

    //

    TMsvId relatedNotificationId = iMmsHeaders->RelatedEntry();

    TInt retval = ReserveNotificationOperationL( relatedNotificationId, KMmsOperationForward );

    if( retval != KErrNone )

        {

        TPckgC < TMsvId > progress = relatedNotificationId;

      	return CMsvCompletedOperation::NewL(

      	    Session(),

      	    KUidMsgMMSNotification,

      	    progress, // progress contains the related entry id

      	    iServiceId,

      	    aCompletionStatus,

      	    KErrInUse);

        }

    //

    // Create the selection to be sent

    //

    CMsvEntrySelection* selection = new( ELeave ) CMsvEntrySelection;

    CleanupStack::PushL( selection ); // ***

    selection->AppendL( iMsvEntry->Entry().Id() );

    //

    // Make sure the message is in OUTBOX

    //

    TMsvId currentParent = iMsvEntry->Entry().Parent();

    if ( currentParent != KMsvGlobalOutBoxIndexEntryId )

        {

        CMsvEntry* cEntry = NULL;

        cEntry = Session().GetEntryL( currentParent );

        CleanupStack::PushL( cEntry );

        cEntry->MoveL( iMsvEntry->Entry().Id(), KMsvGlobalOutBoxIndexEntryId );

        CleanupStack::PopAndDestroy( cEntry );

        }

    //

    // Create parameters structure

    //

    TCommandParameters parameters;

    TTime now;

    now.UniversalTime();

    if ( aSendingTime > now )

        {

        aSendingTime.SecondsFrom( now, parameters.iInitialDelay );

        }

    TCommandParametersBuf paramPack( parameters );

    //

    // Call Server MTM

    //

    CMsvOperation* op = InvokeAsyncFunctionL(

        EMmsScheduledForward,

        *selection,

        paramPack,

        aCompletionStatus );

    //

    // Cleanup and return

    //

    CleanupStack::PopAndDestroy( selection );

    return op;

    }

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

// CMmsClientNotificationMtm::SendL

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

//

CMsvOperation* CMmsNotificationClientMtm::SendL(

    CMsvEntrySelection& /*aSelection*/,

    TRequestStatus& /*aCompletionStatus*/,

    TTime /*aSendingTime*/ )

    {

    User::Leave( KErrNotSupported );

    return NULL; // makes the compiler happy

    }

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

// CMmsClientNotificationMtm::ReserveNotificationOperationL

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

//

TInt CMmsNotificationClientMtm::ReserveNotificationOperationL( 

    TMsvId aNotifId,

    const TUint32 aOperation )

    {

    //

    // Get hands on index entry based on entryId

    //

    CMsvEntry* cEntry = NULL;

    cEntry = Session().GetEntryL( aNotifId );

    CleanupStack::PushL( cEntry ); // ***

    TMsvEntry tEntry = cEntry->Entry();

    //

    // Check that entry is a notification

    //

    if( cEntry->Entry().iType != KUidMsvMessageEntry

        || cEntry->Entry().iMtm != KUidMsgMMSNotification )

        {

        CleanupStack::PopAndDestroy( cEntry );

        return KErrNotSupported;

        }

    //

    // Make some checks concerning the current status of notification and

    // return with error if reservation is not possible

    //

    // if operation is forbidden OR

    // if ( (the aOperation is fetch or forward) and notification is deleted successfully from mmbox)

    if( tEntry.iMtmData2 & KMmsNewOperationForbidden ||

        ( ( aOperation == KMmsOperationFetch || aOperation == KMmsOperationForward ) &&

        tEntry.iMtmData2 & KMmsOperationFinished && 

        ! ( tEntry.iMtmData2 & KMmsOperationResult ) &&

        ! ( tEntry.iMtmData2 & KMmsStoredInMMBox ) &&

        tEntry.iMtmData2 & KMmsOperationDelete ) )

        {

        CleanupStack::PopAndDestroy( cEntry );

        return KErrInUse;        

        }

    //

    // Set the flags

    //

    // reserve the operation

    MarkNotificationOperationReserved( tEntry, aOperation );

    tEntry.SetReadOnly( EFalse );

    //

    // Save the entry

    //

    cEntry->ChangeL( tEntry );

    CleanupStack::PopAndDestroy( cEntry );

    return KErrNone;

    }

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

// CMmsNotificationClientMtm::MarkFreeNotificationsReservedL

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

//

void CMmsNotificationClientMtm::MarkFreeNotificationsReservedL(

    CMsvEntrySelection& aNotifications, const TUint32 aOperation )

    {

    TInt count = aNotifications.Count();

    if ( count == 0 )

        {

        return;

        }

    CMsvEntry* clientEntry = Session().GetEntryL( aNotifications.At( 0 ));

    CleanupStack::PushL( clientEntry );

    for ( TInt i = aNotifications.Count() - 1 ; i >= 0 ; --i ) 

        {

        TBool drop = EFalse;

        TBool alreadyMarked = EFalse;

        clientEntry->SetEntryL( aNotifications.At( i ) );

        TMsvEntry entry = clientEntry->Entry();

        TMsvId duplicate = KMsvNullIndexEntryId;

        if ( FreeNotification( entry, aOperation ) )

            {

            // Check possible duplicate, if mmbox folder even exists

            TMsvId mmboxFolder = iMmsSettings->MMBoxFolder();

            if ( mmboxFolder != KMsvNullIndexEntryId )

                {

                TMsvId parent = entry.Parent();

                CMmsHeaders* mmsHeaders = CMmsHeaders::NewL( iMmsSettings->MmsVersion() );

                CleanupStack::PushL( mmsHeaders );

                CMsvStore* store = clientEntry->ReadStoreL();

                CleanupStack::PushL( store );

                mmsHeaders->RestoreL( *store );

                CleanupStack::PopAndDestroy( store );

                store = NULL;

                if ( parent == KMsvGlobalInBoxIndexEntryId )

                    {

                    FindDuplicateNotificationL( mmboxFolder, 

                        *mmsHeaders, duplicate );

                    }

                else if ( parent == mmboxFolder )

                    {

                    FindDuplicateNotificationL( KMsvGlobalInBoxIndexEntryId, 

                        *mmsHeaders, duplicate );

                    }

                else

                    {

                    // keep LINT happy

                    }

                if ( duplicate != KMsvNullIndexEntryId )

                    {

                    // check if duplicate is free for a operation

                    clientEntry->SetEntryL( duplicate );

                    TMsvEntry dupEntry = clientEntry->Entry();

                    if ( FreeNotification( dupEntry, aOperation ))

                        {

                        // if original notification is in mmbox folder

                        // mark the duplicate reserved too.

                        if ( parent == mmboxFolder )

                            {

                            MarkNotificationOperationReserved( dupEntry, aOperation );

                            clientEntry->ChangeL( dupEntry );

                            clientEntry->SetEntryL( aNotifications.At( i ) );

                            entry = clientEntry->Entry();

                            MarkNotificationOperationReserved( entry, aOperation );

                            entry.SetReadOnly( EFalse );

                            clientEntry->ChangeL( entry );

                            alreadyMarked = ETrue;

                            store = clientEntry->EditStoreL();

                            CleanupStack::PushL( store );

                            mmsHeaders->RestoreL( *store );

                            mmsHeaders->SetRelatedEntry( duplicate );

                            mmsHeaders->StoreL( *store );

                            store->CommitL();

                            CleanupStack::PopAndDestroy( store );

                            store = NULL; 

                            }

                        clientEntry->SetEntryL( aNotifications.At( i ) );

                        }

                    else // duplicate is not free-> original notification has to be dropped

                        {

                        drop = ETrue;

                        }

                    }

                CleanupStack::PopAndDestroy( mmsHeaders );

                }

            }

        else // original notification is not free

            {

            drop = ETrue;

            }

        if ( drop )

            {

            // Remove the entry from selection

            aNotifications.Delete( i );

            }

        else // mark original notification reserved, unless it is already marked

            {

            if ( !alreadyMarked) 

                {

                clientEntry->SetEntryL( aNotifications.At( i ) );              

                entry = clientEntry->Entry();

                MarkNotificationOperationReserved( entry, aOperation );

                entry.SetReadOnly( EFalse );

                clientEntry->ChangeL( entry );

                }   

            }

        }

    aNotifications.Compress();

    CleanupStack::PopAndDestroy( clientEntry );

    }

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

// CMmsNotificationClientMtm::FreeNotification

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

//       

TBool CMmsNotificationClientMtm::FreeNotification( TMsvEntry& aEntry, const TUint32 aOperation )

    {

    if ( aEntry.iMtm != KUidMsgMMSNotification)

        {

        return EFalse;

        }

    if ( aEntry.iMtmData2 & KMmsNewOperationForbidden ||

        ( aEntry.iMtmData2 & KMmsOperationFinished &&

        !( aEntry.iMtmData2 & KMmsOperationResult ) &&

        !( aEntry.iMtmData2 & KMmsStoredInMMBox ) &&

        ( aOperation == KMmsOperationFetch || aOperation == KMmsOperationForward )))

        {

        return EFalse;

        }

    return ETrue;

    }

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

// CMmsNotificationClientMtm::MarkNotificationOperationReserved

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

//       

void CMmsNotificationClientMtm::MarkNotificationOperationReserved( TMsvEntry& aEntry, 

                                                                  const TUint32 aOperation )

    {

    aEntry.iMtmData2 &= ~KMmsOperationIdentifier;   // clear possible old operation

    aEntry.iMtmData2 |= KMmsNewOperationForbidden;  // forbidden   

    aEntry.iMtmData2 |= KMmsOperationOngoing;       // operation is active

    aEntry.iMtmData2 |= aOperation;                 // operation

    aEntry.iMtmData2 &= ~KMmsOperationFinished;     // not finished

    aEntry.iMtmData2 &= ~KMmsOperationResult;       // not failed  

    }

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

// CMmsNotificationClientMtm::FindDuplicateNotificationL

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

// 

void CMmsNotificationClientMtm::FindDuplicateNotificationL( TMsvId aParent, 

                                                           CMmsHeaders& aHeaders, 

                                                           TMsvId& aDuplicate )

    {

    aDuplicate = KMsvNullIndexEntryId;

    if ( aParent == KMsvNullIndexEntryId )

        {

        return;

        }

    CMsvEntry* cEntry = Session().GetEntryL( aParent );

    CleanupStack::PushL( cEntry );