/*

* Copyright (c) 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:  CS Message Handler, This class caches the conversation server

 *                with the message data and also sends run-time updates to the

 *                server with the message data

 *

*/

// USER INCLUDES

#include "ccsmsghandler.h"

#include "msgbiouids.h"

#include "ccsdefs.h"

// SYSTEM INCLUDES

#include <smsclnt.h>                   

#include <mmsclient.h>

#include <mtclreg.h>

#include <csmsemailfields.h>

#include <txtrich.h>

#include <msvids.h>

#include <e32const.h>

#include <SendUiConsts.h>

#include <pushentry.h> // For services messages

#include <e32cmn.h>

//CONSTANTS

const TInt KMessageArrayGranularity = 50;

// NOTE:- DRAFT ENTRIES ARE NOT HANDLED IN THE PLUGIN

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

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

// CCsMsgHandler::NewL

// Two Phase Construction

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

//

CCsMsgHandler* CCsMsgHandler::NewL(MCsMsgObserver *aMsgObserver)

    {

    PRINT ( _L("Enter CCsMsgHandler::NewL") );

    CCsMsgHandler* self = new ( ELeave ) CCsMsgHandler();

    CleanupStack::PushL( self );

    self->ConstructL(aMsgObserver);

    CleanupStack::Pop( self );

    PRINT ( _L("End CCsMsgHandler::NewL") );

    return self;

    }

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

// CCsMsgHandler::~CCsMsgHandler

// Destructor

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

//

CCsMsgHandler::~CCsMsgHandler()

    {

    PRINT ( _L("Enter CCsMsgHandler::~CCsMsgHandler") );

    if(iIdle)

        {

        iIdle->Cancel();

        delete iIdle;

        iIdle=NULL;

        }

    if(iMsgPluginUtility)

        {

        delete iMsgPluginUtility;

        iMsgPluginUtility = NULL;

        }

    if(iConverstationEntryList)

        {

        iConverstationEntryList->ResetAndDestroy();

        iConverstationEntryList->Close();

        delete iConverstationEntryList;

        iConverstationEntryList = NULL;

        }

    if(iSmsMtm)

        {

        delete iSmsMtm;

        iSmsMtm = NULL;

        }

    if(iMmsMtm)

        {

        delete iMmsMtm;

        iMmsMtm = NULL;

        }

    if(iMtmRegistry)

        {

        delete iMtmRegistry;

        iMtmRegistry = NULL;

        }

    if(iSession)

        {

        delete iSession;

        iSession = NULL;

        }

    if(iMessageArray)

    {

        iMessageArray->Reset();

        iMessageArray->Close();

        delete iMessageArray;

        iMessageArray = NULL;

    }

    PRINT ( _L("End CCsMsgHandler::~CCsMsgHandler") );

    }

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

// CCsMsgHandler::ConstructL

// Two Phase Construction

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

//

void CCsMsgHandler::ConstructL(MCsMsgObserver *aMsgObserver)

    {

    PRINT ( _L("Enter CCsMsgHandler::ConstructL") );

    iMsgObserver = aMsgObserver;

    iSession = CMsvSession::OpenSyncL(*this);

    iMsgPluginUtility = CCsMsgPluginUtility::NewL();

    iConverstationEntryList = new(ELeave) RPointerArray<CCsConversationEntry>(1);

    iMtmRegistry = CClientMtmRegistry::NewL( *iSession );

    iSmsMtm = static_cast<CSmsClientMtm*>( iMtmRegistry->

            NewMtmL( KSenduiMtmSmsUid ) );

    iMmsMtm = static_cast<CMmsClientMtm*>( iMtmRegistry->

            NewMtmL( KSenduiMtmMmsUid ) );

    iState = EReadInbox;

    iMessageArray = new (ELeave)RArray <TMsvId>(KMessageArrayGranularity);

    PRINT ( _L("End CCsMsgHandler::ConstructL") );

    }

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

// CCsMsgHandler::CCsMsgHandler

// Two Phase Construction

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

//

CCsMsgHandler::CCsMsgHandler()

    {

    }

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

// CCsMsgHandler::ProcessResultsL()

// ProcessResultsL fetches results for the searchsort query and

// updates the CCsServer with the fetched data

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

//

void CCsMsgHandler::ProcessResultsL(TMsvEntry entry)

    {

    PRINT ( _L("Enter CCsMsgHandler::ProcessResultsL"));

    // Cleanup the conversationEntry List initially.

    // So that the previous entries not cleaned up in

    // the event of Leave have been clean up.

    iConverstationEntryList->ResetAndDestroy();

    RPointerArray<HBufC> addressList;

    // Ignore hidden items during upload

    if ( entry.Visible() == EFalse )

        {

        return;

        }

    if ( entry.Parent() == KMsvGlobalInBoxIndexEntryIdValue ||

         entry.Parent() == KMsvSentEntryIdValue ||

         entry.Parent() == KMsvGlobalOutBoxIndexEntryIdValue )

        {

        CleanupResetAndDestroyPushL(addressList);

        iMsgPluginUtility->CreateContactL(iSession, entry, addressList);

        //process entry

        ExtractAddressesL(entry, ERead, addressList);

        // Cleanup addressList

        CleanupStack::PopAndDestroy(&addressList);

        }

    PRINT ( _L("Exit CCsMsgHandler::ProcessResultsL") );

    }

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

// CCsMsgHandler::HandleSessionEventL

// Implemented for MMsvSessionObserver

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

//

void CCsMsgHandler::HandleSessionEventL( TMsvSessionEvent aEvent,

        TAny* aArg1,

        TAny* aArg2,

        TAny* /*aArg3*/)

    {

    PRINT1 ( _L("Enter CCsMsgHandler::HandleSessionEventL aEvent=%d"),aEvent );

    CMsvEntrySelection* selection=NULL;

    TMsvId parent;

    //args

    if(aArg1 == NULL || aArg2 == NULL)

        {

        PRINT ( _L("Enter CCsMsgHandler::HandleSessionEventL arguments invalid"));

        return;

        }

    //start, processing the event

    selection= (CMsvEntrySelection*)aArg1;

    parent = *(TMsvId*)aArg2;

    // Cleanup the conversationEntry List initially.

    iConverstationEntryList->ResetAndDestroy();

    switch( aEvent )

        {

        case EMsvEntriesChanged:

        case EMsvEntriesMoved:

            {

            HandleEventL(selection,parent);

            }

            break;

        case EMsvEntriesDeleted:

            {

            if ( parent == KMsvGlobalInBoxIndexEntryIdValue || 

                 parent == KMsvSentEntryIdValue ||

                 parent == KMsvGlobalOutBoxIndexEntryIdValue)

                {

                for( TInt i=0 ; i < selection->Count() ; i++ )

                    {

                    TMsvId id = selection->At( i );

                    //use utility to create conversation entry

                    CCsConversationEntry *conversationEntry = 

                    iMsgPluginUtility->CreateConversationEntryL(

                            NULL,

                            id,

                            0,

                            parent,

                            NULL,

                            ECsSendStateUnknown,

                            ECsAttributeNone,

                            0);

                    CleanupStack::PushL(conversationEntry);

                    iConverstationEntryList->AppendL( conversationEntry );

                    CleanupStack::Pop(conversationEntry);

                    // call observer interface for each entry

                    iMsgObserver->HandleDeleteCompleteL(iConverstationEntryList);

                    //cleanup before next iteration

                    iConverstationEntryList->ResetAndDestroy();

                    }

                }

            }

            break;

        case EMsvMediaChanged:

            iMsgObserver->HandleRefreshCompleteL();

            break;

        }

    // Cleanup the conversationEntry List before function exits.

    iConverstationEntryList->ResetAndDestroy();

    PRINT ( _L("Exit CCsMsgHandler::HandleSessionEventL") );

    }

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

// CCsMsgHandler::HandleEvent

// Handle events

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

//

void CCsMsgHandler::HandleEventL(CMsvEntrySelection* aSelection, TMsvId aParent)

    {

    PRINT ( _L("Enter CCsMsgHandler::HandleEvent") );

    TMsvEntry entry;

    TMsvId service;

    TInt error= KErrNone;

    RPointerArray<HBufC> addressList;

    for( TInt i=0 ; i < aSelection->Count() ; i++ )

        {

        error = iSession->GetEntry(aSelection->At(i),service,entry);

            // Do a delete if entry becomes invisible.

            // e.g) My Nokia registration messages.

            RPointerArray<CCsConversationEntry>* hiddenEntries =  

                    new (ELeave) RPointerArray<CCsConversationEntry>();

            CCsConversationEntry *conversationEntry = 

                    iMsgPluginUtility->CreateConversationEntryL ( 

                            NULL,

                            entry.Id(),

                            0,

                            aParent,

                            NULL,

                            ECsSendStateUnknown,

                            ECsAttributeNone,

                            0 );  

            CleanupStack::PushL(conversationEntry);

            hiddenEntries->AppendL( conversationEntry );

            CleanupStack::Pop(conversationEntry);

            // Delete at server

            iMsgObserver->HandleDeleteCompleteL(hiddenEntries);

            hiddenEntries->ResetAndDestroy();

            hiddenEntries->Close();

            delete hiddenEntries;

            break;

            }

        if ( (KErrNone == error) && (IsMtmSupported(entry.iMtm.iUid) ) )

            {

            // sent/inbox/Outbox entry

            if ( aParent == KMsvSentEntryIdValue ||

                 aParent == KMsvGlobalInBoxIndexEntryIdValue )

                {

                CleanupResetAndDestroyPushL(addressList);

                // currently server needs number, so getting it from header

                iMsgPluginUtility->CreateContactL(iSession, entry,

                        addressList);

                //process entry

                // entry created in sent already exists, hence an update

                ExtractAddressesL(entry, EUpdate, addressList);

                CleanupStack::PopAndDestroy(&addressList);

                }  

            //for drafts and outbox, the entry changes multiple times,

            // so making a check if entry has changed

            else if(aParent == KMsvGlobalOutBoxIndexEntryIdValue)

                {

                //outbox

                if(!(iMsgPluginUtility->CompareEntry(iPrevEntry,entry,aParent)))

                    {

                    TUint sendState = entry.SendingState();

                    // if the entry state is sent, we dont need to process it

                    // as it is going to appear in sent items

                    if( ECsSendStateSent != iMsgPluginUtility->GetSendState(entry) )

                        {

                         CleanupResetAndDestroyPushL(addressList);

                        // currently server needs number, so getting it from header

                        iMsgPluginUtility->CreateContactL(iSession, entry,

                                addressList);

                        //process entry

                        // entry created in sent already exists, hence an update

                        ExtractAddressesL(entry, EUpdate, addressList);

                        iPrevEntry = entry;

                        CleanupStack::PopAndDestroy(&addressList);

                        }

                    }//end check changed entry

                }

            }

        }//end for loop

    PRINT ( _L("Exit CCsMsgHandler::HandleEvent") );

    }

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

// CCsMsgHandler::CreateAndAddEntryL

// Creates CCsConversationEntry and adds to the list

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

//

void CCsMsgHandler::CreateAndAddEntryL(const TDesC& aContact, 

        const TDesC& aDescription, 

        const TMsvEntry& aEntry)

    {

    PRINT ( _L("Enter CCsMsgHandler::CreateAndAddEntryL") );

    HBufC* contact = NULL;

    HBufC* sDescription = NULL;

    if (aContact.Length()>0)

        {

        contact = aContact.AllocLC();

        }

    if (aDescription.Length()>0)

        {

        sDescription = aDescription.AllocLC();

        }

    //use utility to create conversation entry

    CCsConversationEntry *conversationEntry = iMsgPluginUtility->CreateConversationEntryL(

            contact,

            aEntry.Id(),

            aEntry.iDate.Int64(),

            aEntry.Parent(),

            sDescription,

            iMsgPluginUtility->GetSendState(aEntry),

            iMsgPluginUtility->GetMsgAttributes(aEntry),

            ExtractCsType(aEntry));

    CleanupStack::PushL(conversationEntry);

    //add to the list

    iConverstationEntryList->AppendL( conversationEntry );

    CleanupStack::Pop(conversationEntry);

    // cleanup

    if (sDescription)

        {

        CleanupStack::PopAndDestroy(sDescription);

        }

    if (contact)

        {

        CleanupStack::PopAndDestroy(contact);

        }

    PRINT ( _L("Exit CCsMsgHandler::CreateAndAddEntryL") );

    }

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

// CCsMsgHandler::ProcessEntryL

// Creates CCsConversationEntry and adds to the list

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

//

void CCsMsgHandler::ProcessEntryL( TEventType aEvent, const TDesC& aContact, 

        const TDesC& aDescription, const TMsvEntry& aEntry)

    {

    PRINT ( _L("Enter CCsMsgHandler::ProcessEntryL") );

    // create and add entry to the list

    CreateAndAddEntryL(aContact,aDescription,aEntry);

    // call cs observer interface for each entry

    switch(aEvent)

        {

        case ERead:

            {

            iMsgObserver->HandleReadCompleteL(iConverstationEntryList);

            }

            break;

        case EUpdate:

            {

            iMsgObserver->HandleUpdateCompleteL(iConverstationEntryList);

            }

            break;

        }

    // Cleanup the conversationEntry List, as we are just sending one entry at a time

    iConverstationEntryList->ResetAndDestroy();

    PRINT ( _L("Exit CCsMsgHandler::ProcessEntryL") );

    }

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

// CCsMsgHandler::ExtractAddressL

// Extracts the addresses in the to field and updates them to server

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

//

void CCsMsgHandler::ExtractAddressesL( 

        TMsvEntry aEntry, 

        TEventType aEvent, 

        RPointerArray<HBufC>& addressList )

    {

    PRINT ( _L("Enter CCsMsgHandler::ExtractAddressesL") );

    // For SMS read the whole body.

    // For bio type SMS read the iDescription

    // For other message types read the iDescription

    // Note: After the LoadMessageL() the iDescription is getting 

    // deleted so need to make a copy before that.

    TPtrC description;

    HBufC* tmpBuffer = NULL;

    if ( (aEntry.iBioType && 

	      aEntry.iBioType != KUidMsgSubTypeMmsAudioMsg.iUid ) || 

		  aEntry.iMtm == KSenduiMtmBtUid ) 

        {

        tmpBuffer = aEntry.iDescription.AllocLC();

        description.Set( tmpBuffer->Des() );         

        }    

    else if ( aEntry.iMtm == KSenduiMtmSmsUid )  

        {

        iSmsMtm->SwitchCurrentEntryL( aEntry.Id() );