/*

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

*     State machine for mmbox list

*

*/

// INCLUDE FILES

#include    <logcli.h>

#include    <msvids.h>

#include    <msventry.h>

#include    <msvstd.h>

#include    <e32std.h> // TTime

// the rest are local includes

#include    "mmsmmboxlist.h"

#include    "mmsconst.h"

#include    "mmsencode.h"

#include    "mmsdecode.h"

#include    "mmsheaders.h"

#include    "mmsmmboxviewheaders.h"

#include    "mmsserverentry.h"

#include    "mmssettings.h"

#include    "mmssession.h"

#include    "mmserrors.h"

#include    "MmsServerDebugLogging.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

_LIT( K1970, "19700000:000000.000000" );    // 1-Jan 1970 0:00:00

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

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

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

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

// CMmsMmboxList::CMmsMmboxList

//

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

//

CMmsMmboxList::CMmsMmboxList( RFs& aFs ):

    CMmsBaseOperation( aFs )

    {

    }

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

// CMmsMmboxList::ConstructL

//

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

//

void CMmsMmboxList::ConstructL( CMmsSettings* aMmsSettings )

    {

    CMmsBaseOperation::ConstructL( aMmsSettings );

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

    iOldNotifications = new ( ELeave ) CMsvEntrySelection;

    CActiveScheduler::Add( this );

    }

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

// CMmsMmboxList::NewL

//

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

//

CMmsMmboxList* CMmsMmboxList::NewL( RFs& aFs, CMmsSettings* aMmsSettings  )

    {

    CMmsMmboxList* self = new ( ELeave ) CMmsMmboxList( aFs );

    CleanupStack::PushL( self );

    self->ConstructL( aMmsSettings );

    CleanupStack::Pop( self );

    return self;

    }

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

// CMmsMmboxList::~CMmsMmboxList

//

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

//

CMmsMmboxList::~CMmsMmboxList()

    {

    Cancel(); // has to be called first

    delete iOldNotifications;

    delete iMmsHeaders;

    }

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

// CMmsMmboxList::StartL

//

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

//

void CMmsMmboxList::StartL(

            CMsvEntrySelection& aSelection,

            CMsvServerEntry& aServerEntry,

            TMsvId aService,

            TRequestStatus& aStatus )

    {

    LOG( _L("CMmsMmboxList::StartL") );

    // Make sure that the aSelection is empty

    aSelection.Reset();

    CMmsBaseOperation::InitializeL( aSelection, aServerEntry, aService );

    iMmsHeaders->Reset();

    iOldNotifications->Reset();

    // get current notifications from mmbox folder 

    iMmboxFolder = iMmsSettings->MMBoxFolder();

    if ( iError == KErrNone )

        {

        iError = iServerEntry->SetEntry( iMmboxFolder );

        }

    // If cannot access MMBoxFolder, we are in trouble

    // When iError not equal to KErrNone, the operation will complete after running through RunL

    if ( iError == KErrNone )

        {

        iServerEntry->GetChildrenWithMtm( KUidMsgMMSNotification, *iOldNotifications );

        iOldQuotaEntryId = OldQuotaEntryL();

        }

    else

        {

        iOldQuotaEntryId = KMsvNullIndexEntryId;

        }

    iServerEntry->SetEntry( KMsvNullIndexEntryId );

    Queue( aStatus );

    FallThrough();   

    }

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

// CMmsMmboxList::DoCancel

//

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

//

void CMmsMmboxList::DoCancel()

    {

    LOG( _L("CMmsMmboxList::DoCancel") );

    CMmsBaseOperation::DoCancel();

    }

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

// CMmsMmboxList::EncodePDUL

//

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

//

void CMmsMmboxList::EncodePDUL()

    {

    LOG( _L("CMmsMmboxList::EncodePDU") );

    // As no entry exists to be encoded, mmsheaders are not restored and stored.

    //  Set message type

    iMmsHeaders->SetMessageType( KMmsMessageTypeMboxViewReq );

    // Request mmbox total and quota information 

    CMmsMMBoxViewHeaders& viewHeaders = iMmsHeaders->MMBoxViewHeadersL();

    viewHeaders.SetMmsTotals( KMmsYes );

    viewHeaders.SetMmsQuotas( KMmsYes );

    // Set TransactionId

    TBufC8<KMMSMAXTIDLENGTH> tid;

    tid.Des().NumUC( AllocateTID(), EHex );

    iMmsHeaders->SetTidL( tid );

    // Encode the mmboxview request

    iEncoder->EncodeHeadersL( *iMmsHeaders, *iEncodeBuffer );

    FallThrough();

    }

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

// CMmsMmboxList::SubmitTransactionL

//

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

//

void CMmsMmboxList::SubmitTransactionL()

    {

    LOG( _L("CMmsMmboxList::SubmitTransaction"));

    if ( !iConnected )

        {

        if ( iError == KErrNone )

            {

            iError = KErrCouldNotConnect;

            }

        }

    // This check is needed only when running tests in global mode

    // if length of URI is 0, Symbian code will panic    

    if ( !iUri )

        {

        if ( !iMmsSettings->LocalMode() )

            {

            iError = KMmsErrorNoURI1;

            }

        }

    else if ( iUri->Des().Length() == 0 && !iMmsSettings->LocalMode() )

        {

        iError = KMmsErrorNoURI1;

        }

    if ( iError != KErrNone )

        {

        FallThrough();

        return;

        }

    if ( !iMmsSettings->LocalMode() )

        {

        // Send

        iMmsSession->SendMessageL(

            iUri->Des(),

            *iEncodeBuffer,

            *iEncoder,

            *iDecoder,

            iStatus );

        SetActive();

        }

    else

        {

        LocalModeFetchL();

        }

    }

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

// CMmsMmboxList::CreateEntryL

//

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

//

void CMmsMmboxList::CreateEntryL()

    {

    LOG( _L("CMmsMmboxList CreateEntry"));

    // Create an mms entry under mmbox folder

    if ( iOldQuotaEntryId != KMsvNullIndexEntryId )

        {

        // Reuse old quota

        iEntryUnderConstruction = iOldQuotaEntryId;

        }

    else

        {

        // If no old quota entry exists, we create a new one

        iError = iServerEntry->SetEntry( iMmboxFolder );

        if ( iError == KErrNone )

            {

            // set all relevant flags in tMsvEntry

            TMsvEntry tEntry;

            tEntry.iMtm = KUidMsgTypeMultimedia;

            tEntry.iDate.UniversalTime();

            SetFirstFlagsToNewEntry( tEntry );

            iError = iServerEntry->CreateEntry( tEntry );

            if ( iError == KErrNone )

                {

                iEntryUnderConstruction = tEntry.Id();

                }

            }

        iServerEntry->SetEntry( KMsvNullIndexEntryId );

        }

    FallThrough();

    }

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

// CMmsMmboxList::DecodeResponseL

//

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

//

void CMmsMmboxList::DecodeResponseL()

    {

    LOG( _L("CMmsMmboxList::DecodeResponseL"));

    if( iEncodeBuffer->Size() < 1 )

        {

        iError  = KErrCorrupt; 

        } 

    if( iError != KErrNone ) 

        {

        FallThrough();

        return;

        }

    iMmsHeaders->Reset();    

    // Decode mmbox view confirmation

    TInt numAtt = 0;

    TInt dataStart = 0;

    TInt startInBuffer = 0;

    TInt length = iEncodeBuffer->Size();

    iDecoder->DecodeHeadersL( *iEntryWrapper,

        *iMmsHeaders, 

        *iEncodeBuffer,

        startInBuffer,

        length,

        &numAtt,

        &dataStart );

    // The content type have to be mmbox view conf. 

    if ( iMmsHeaders->MessageType() != KMmsMessageTypeMboxViewConf )

        {

        // the content type is not correct. Don't save the headers

        if ( iMmsHeaders->MessageType() == KMmsMessageTypeMSendConf &&

             iMmsHeaders->ResponseStatus() == KMmsErrorUnsupportedMessage ) 

            {

            iError = KErrNotSupported;

            }

        else

            {

            iError = KErrCorrupt;

            }

        }

    if ( iError == KErrNone )

        {

        if ( iOldQuotaEntryId != KMsvNullIndexEntryId )

            {

            // We must make the entry read only again

            iError = iServerEntry->SetEntry( iOldQuotaEntryId );

            if ( iError == KErrNone )

                {

                TMsvEntry tEntry = iServerEntry->Entry();

                tEntry.SetReadOnly( EFalse );

                iServerEntry->ChangeEntry( tEntry );

                }

            iServerEntry->SetEntry( KMsvNullIndexEntryId );

            }

        iError = iEntryWrapper->SetCurrentEntry( iEntryUnderConstruction );

        }

    // save the mmbox view confirmation headers, 

    // as the decode does not save them

    if ( iError == KErrNone )

        {

        iError = iEntryWrapper->StoreMmsHeadersL( *iMmsHeaders, NULL );

        }

    // decode rest of the PDUs if we have any.

    TInt start = dataStart; // start of multipart data.

    for ( TInt i = 0; i < numAtt && iError == KErrNone; i++ )

        {

        length = iEncodeBuffer->Size() - start;

        // We extract next data part, but we don't use the mime headers that would be returned

        iDecoder->ExtractNextDataPartL( *iEncodeBuffer,

            start, // start of next data part

            dataStart, // start of actual data

            length ); // length of data

        // Create a new entry for the mmbox description PDU

        iError = iServerEntry->SetEntry( iMmboxFolder );

        TMsvEntry descEntry;

        if ( iError == KErrNone )

            {

            // set all relevant flags in tMsvEntry

            descEntry.iMtm = KUidMsgMMSNotification;

            SetFirstFlagsToNewEntry( descEntry );

            iError = iServerEntry->CreateEntry( descEntry );

            }

        if ( iError == KErrNone )

            {                         

            // Decode description PDU

            iMmsHeaders->Reset();

            TInt attaNum = 0;

            TInt attaDataStart = 0;

            iDecoder->DecodeHeadersL( *iEntryWrapper,

                *iMmsHeaders, 

                *iEncodeBuffer,

                dataStart,

                length,

                &attaNum,

                &attaDataStart );

            iError = iEntryWrapper->SetCurrentEntry( descEntry.Id() );

            }

        // Checking the content type

    	if( iError == KErrNone )

	        {

	        // The content type has to be mmbox view description.

    	    if( iMmsHeaders->MessageType() != KMmsMessageTypeMBoxDescr )

    	        {

                // Content type is not correct.

                iError = KErrCorrupt;

                LOG( _L("ERROR: Wrong content type"));

            	}

            else 

         	    {

                // Mark mmbox notification specific flags

    	        // Mark as notification. This information is important for UI.

                descEntry.iMtmData1 = KMmsMessageMNotificationInd; 

                descEntry.iMtmData2 = KMmsStoredInMMBox;

                descEntry.iMtmData2 |= KMmsNotifyResponseSent;

    	        }

	        }

        if( iError == KErrNone )

            {

            // Set subject etc. to the notification entry

            iError = StoreContentToNotificationEntryL( descEntry );

            }

        if ( iError == KErrNone )

            {

            // Save the headers as the decoder does not save them

            iError = iEntryWrapper->StoreMmsHeadersL( *iMmsHeaders, NULL );

            }

        if ( iError == KErrNone )

            {

            // add new notification to iSelection list

            iSelection->AppendL( descEntry.Id() );

            }

        } // for loop

    iServerEntry->SetEntry( KMsvNullIndexEntryId );

    FallThrough();

    }

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

// CMmsMmboxList::MoveEntryL

//

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

//

void CMmsMmboxList::MoveEntryL()

    {

    LOG( _L("CMmsMmboxList::MoveEntryL"));

    if ( iError != KErrNone )

        {

        FallThrough();

        return;

        }

    // Delete old notifications  

    iError = RemoveOldNotifications();

    // make new notifications visible

    if ( iError == KErrNone )

        {

        iError = MakeNewNotificationsVisible();

        }

    // Finalize the new quota entry - if we created a new one and did not

    // just reuse the old entry

    TMsvEntry tEntry;

    if ( iError == KErrNone || iOldQuotaEntryId == KMsvNullIndexEntryId )

        {

        iError = iServerEntry->SetEntry( iEntryUnderConstruction );

        if ( iError == KErrNone )

            {

            tEntry = iServerEntry->Entry();

            SetFlagsToEntryBeingFinalized( tEntry );

            // update the time the quota entry was updated

            tEntry.iDate.UniversalTime();

            tEntry.iError = KErrNone; // clear possible old error

            // Quota entry must not be visible.

            // Otherwise the shows the number of notifications in mmboxfolder wrong.

            tEntry.SetVisible( EFalse );

            iError = iServerEntry->ChangeEntry( tEntry );

            if ( iError == KErrNone )

                {

                iEntryUnderConstruction = KMsvNullIndexEntryId;

                }

            }

        iServerEntry->SetEntry( KMsvNullIndexEntryId );

        }

    FallThrough();

    }

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

// CMmsMmboxList::FinalizeL()

//

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

//

void CMmsMmboxList::FinalizeL()

    {

    LOG( _L("CMmsMmboxList::FinalizeL"));

    TInt error;

    // In case something has failed. Delete the new quota entry

    // - but only in case it was just created

    if ( iError != KErrNone )

        {

        error = iServerEntry->SetEntry( iMmboxFolder );

        if ( error == KErrNone )

            {

            // we can only delete, if we can set context to parent

            if ( iOldQuotaEntryId == KMsvNullIndexEntryId )

                {

                iServerEntry->DeleteEntry( iEntryUnderConstruction );

                }

            // if iSelection contains now notifications, the notifications

            // are not ready yet. They can be destroyed.

            if ( iSelection->Count() > 0 )

                {

                iServerEntry->DeleteEntries( *iSelection );

                }

            }

        iEntryUnderConstruction = KMsvNullIndexEntryId;

        iSelection->Reset();

        // we don't care if the iOldNotifications is empty or not. 

        // If the old notifications are not deleted, they can stay

        // in the mmbox folder. The array is reseted anyway.

        iOldNotifications->Reset();

        // set iError to old quota entry, if the entry exists

        if ( iOldQuotaEntryId != KMsvNullIndexEntryId )