/*

* Copyright (c) 2009 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:  Functional implementation of HtiMessagesServicePlugin service

*

*/

// INCLUDE FILES

#include "HtiMessagesServicePlugin.h"

#include "MessageMgmntHandler.h"

#include <HtiDispatcherInterface.h>

#include <mtclreg.h>

#include <smscmds.h>

#include <smtcmtm.h>

#include <smuthdr.h>

#include <smsclnt.h>

#include <utf.h>

#include <mmsclient.h>

#include <mmsconst.h>

#include <miutset.h>

#include <irmsgtypeuid.h>

#include <btmsgtypeuid.h>

#include <biouids.h>

#include <apgcli.h>

#include <apmstd.h>

#include <bautils.h>

#include <obexclientmtm.h>

#include <cmsvmimeheaders.h>

#include <mmsvattachmentmanager.h>

// CONSTANTS

_LIT8( KErrorMissingCommand,        "Command was not given - message was empty" );

_LIT8( KErrorUnrecognizedCommand,   "Unrecognized command" );

_LIT8( KErrorInvalidParameters,     "Invalid command parameters");

_LIT8( KErrorTooLongSmsBody,        "Too long SMS body" );

_LIT8( KErrorInvalidId,             "Invalid SMS id parameter" );

_LIT8( KErrorInvalidFolder,         "Invalid folder parameter" );

_LIT8( KErrorItemNotFound,          "Item not found" );

_LIT8( KErrorFailedDelete,          "Failed to delete item" );

_LIT8( KErrorNotSupported,          "Not supported" );

_LIT8( KErrorSmsSettingNotDefined,  "SMS settings not defined" );

_LIT8( KErrorMmsSettingNotDefined,  "MMS settings not defined" );

_LIT8( KErrorMailboxNotDefined,     "Mailbox not defined" );

_LIT8( KErrorMsgTypeNotFound,       "Message type module not found" );

_LIT8( KErrorMsgStoreOpenFailed,    "Could not open message store" );

_LIT8( KErrorRfsConnectFailed,      "Could not connect to file server session" );

_LIT8( KErrorAttachmentNotFound,    "Attachment not found" );

_LIT8( KErrorInvalidFolderForSmartMsg, "Only inbox allowed for smart messages" );

const static TInt KAddSmsCmdMinLength        = 7;

const static TInt KAddMmsOrEmailCmdMinLength = 8;

const static TInt KAddObexMsgCmdMinLength    = 6;

const static TInt KAddSmartMsgCmdMinLength   = 11;

const static TInt KAddAudioCmdMinLength      = 10;

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

CMessageMgmntHandler* CMessageMgmntHandler::NewL()

    {

    HTI_LOG_FUNC_IN( "CMessageMgmntHandler::NewL" );

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

    CleanupStack::PushL ( self );

    self->ConstructL();

    CleanupStack::Pop();

    HTI_LOG_FUNC_OUT( "CMessageMgmntHandler::NewL: Done" );

    return self;

    }

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

CMessageMgmntHandler::CMessageMgmntHandler()

    {

    }

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

CMessageMgmntHandler::~CMessageMgmntHandler()

    {

    delete iMtmReg;

    delete iSession;

    }

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

void CMessageMgmntHandler::ConstructL()

    {

    HTI_LOG_FUNC_IN( "CMessageMgmntHandler::ConstructL" );

    iSession = CMsvSession::OpenSyncL( *this );

    iMtmReg = CClientMtmRegistry::NewL( *iSession );

    HTI_LOG_FUNC_OUT( "CMessageMgmntHandler::ConstructL: Done" );

    }

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

void CMessageMgmntHandler::SetDispatcher( MHtiDispatcher* aDispatcher )

    {

    iDispatcher = aDispatcher;

    }

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

void CMessageMgmntHandler::ProcessMessageL( const TDesC8& aMessage,

                                            THtiMessagePriority /*aPriority*/ )

    {

    HTI_LOG_FUNC_IN( "CMessageMgmntHandler::ProcessMessageL" );

    HTI_LOG_FORMAT( "Msg length: %d", aMessage.Length() );

    if ( aMessage.Length() == 0 )

        {

        SendErrorMessageL( KErrArgument, KErrorMissingCommand );

        return;

        }

    switch ( aMessage[0] )

        {

        case CHtiMessagesServicePlugin::EAddSms:

            HTI_LOG_TEXT( "Add SMS" );

            HandleCreateSmsL( aMessage.Right( aMessage.Length() - 1 ) );

            break;

        case CHtiMessagesServicePlugin::EAddMms:

        case CHtiMessagesServicePlugin::EAddAudioMsg: // special MMS sub type

            HTI_LOG_TEXT( "Add MMS" );

            HandleCreateMmsL( aMessage );

            break;

        case CHtiMessagesServicePlugin::EAddEmail:

            HTI_LOG_TEXT( "Add Email" );

            HandleCreateEmailL( aMessage );

            break;

        case CHtiMessagesServicePlugin::EAddIrMsg:

            HTI_LOG_TEXT( "Add IR msg" );

            HandleCreateObexMsgL( aMessage.Right( aMessage.Length() - 1 ),

                                  TUid::Uid( KUidMsgTypeIrTInt32 ),

                                  KUidMsgTypeIrUID );

            break;

        case CHtiMessagesServicePlugin::EAddBtMsg:

            HTI_LOG_TEXT( "Add BT msg" );

            HandleCreateObexMsgL( aMessage.Right( aMessage.Length() - 1 ),

                                  TUid::Uid( KUidMsgTypeBtTInt32 ),

                                  KUidMsgTypeBt );

            break;

        case CHtiMessagesServicePlugin::EAddSmartMsg:

            HTI_LOG_TEXT( "Add smart msg" );

            HandleCreateSmartMsgL( aMessage.Right( aMessage.Length() - 1 ) );

            break;

        case CHtiMessagesServicePlugin::EDeleteMessage:

            HTI_LOG_TEXT( "Delete message" );

            HandleDeleteMessageL( aMessage.Right( aMessage.Length() - 1 ) );

            break;

        case CHtiMessagesServicePlugin::EDeleteFolderContent:

            HTI_LOG_TEXT( "Delete messages" );

            HandleDeleteMessagesL( aMessage.Right( aMessage.Length() - 1 ) );

            break;

        default:

            HTI_LOG_TEXT( "Unknown command" );

            SendErrorMessageL( KErrUnknown, KErrorUnrecognizedCommand );

            break;

        }

    HTI_LOG_FUNC_OUT( "CMessageMgmntHandler::ProcessMessageL: Done" );

    }

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

void CMessageMgmntHandler::HandleCreateSmsL( const TDesC8& aData )

    {

    HTI_LOG_FUNC_IN( "CMessageMgmntHandler::HandleSmsImportFuncL" );

    if ( ValidateAddSmsCommand( aData ) )

        {

        TInt position( 0 );

        HBufC16* fromTo = ExtractDesLC( aData, position, 1 );

        HBufC16* description = ExtractDesLC( aData, position, 1 );

        HBufC16* body = ExtractDesLC( aData, position, 2 );

        TBool isNew = (TBool)aData[position];

        TBool isUnread = (TBool)aData[position+1];

        TFolder folder = (TFolder)aData[position+2];

        CSmsClientMtm* smsMtm = NULL;

        TRAPD( err, smsMtm = ( CSmsClientMtm* )iMtmReg->NewMtmL(

                KUidMsgTypeSMS ) );

        if ( err || !smsMtm )

            {

            HTI_LOG_TEXT( "SMS message type module not found" );

            SendErrorMessageL( KErrNotFound, KErrorMsgTypeNotFound );

            CleanupStack::PopAndDestroy( body );

            CleanupStack::PopAndDestroy( description );

            CleanupStack::PopAndDestroy( fromTo );

            return;

            }

        CleanupStack::PushL( smsMtm );

        CMsvEntry* entry = CMsvEntry::NewL( *iSession,

                                            KMsvGlobalInBoxIndexEntryId,

                                            TMsvSelectionOrdering() );

        CleanupStack::PushL( entry );

        // get the default service

        TMsvId defaultServiceId = 0;

        TRAP( err, defaultServiceId = smsMtm->DefaultServiceL() );

        if ( err )

            {

            HTI_LOG_FORMAT( "Could not get default service, err: %d", err );

            SendErrorMessageL( err, KErrorSmsSettingNotDefined );

            CleanupStack::PopAndDestroy( entry );

            CleanupStack::PopAndDestroy( smsMtm );

            CleanupStack::PopAndDestroy( body );

            CleanupStack::PopAndDestroy( description );

            CleanupStack::PopAndDestroy( fromTo );

            return;

            }

        // map the folder parameter to folder id

        TMsvId folderId = KMsvGlobalInBoxIndexEntryId;

        TRAP( err, folderId = MapFolderToIdL( folder ) );

        if ( err )

            {

            HTI_LOG_FORMAT( "Invalid folder: %d", folder );

            SendErrorMessageL( err, KErrorInvalidFolder );

            CleanupStack::PopAndDestroy( entry );

            CleanupStack::PopAndDestroy( smsMtm );

            CleanupStack::PopAndDestroy( body );

            CleanupStack::PopAndDestroy( description );

            CleanupStack::PopAndDestroy( fromTo );

            return;

            }

        entry->SetEntryL( folderId );

        // mtm takes ownership of entry context

        smsMtm->SetCurrentEntryL( entry );

        CleanupStack::Pop( entry );

        // create a new message

        smsMtm->CreateMessageL( defaultServiceId );

        if ( folder == EInbox )

            {

            CSmsHeader* smsHeader = &( smsMtm->SmsHeader() );

            delete smsHeader;

            smsHeader = NULL;

            smsHeader = CSmsHeader::NewL( CSmsPDU::ESmsDeliver, smsMtm->Body() );

            smsHeader->SetFromAddressL( fromTo->Des() );

            }

        else

            {

            smsMtm->AddAddresseeL( fromTo->Des() );

            // set delivery settings

            CSmsSettings* sendOptions = CSmsSettings::NewL();

            CleanupStack::PushL( sendOptions );

            sendOptions->CopyL( smsMtm->ServiceSettings() );

            sendOptions->SetDelivery( ESmsDeliveryImmediately );

            CSmsHeader* smsHeader = &( smsMtm->SmsHeader() );

            smsHeader->SetSmsSettingsL( *sendOptions );

            CleanupStack::PopAndDestroy( sendOptions );

            }

        // set body

        smsMtm->Body().Reset();

        smsMtm->Body().InsertL( 0, *body );

        // save the message

        smsMtm->SaveMessageL();

        // get the entry of the message

        TMsvEntry tentry = smsMtm->Entry().Entry();

        // set the details field

        tentry.iDetails.Set( fromTo->Des() );

        // set the description field if it is given.

        // (with no description the beginning of the message body

        //  is used as a description)

        if ( description->Length() > 0 )

            {

            tentry.iDescription.Set( description->Des() );

            }

        // final fine tuning

        tentry.SetAttachment( EFalse );

        tentry.iDate.UniversalTime();

        tentry.SetVisible( ETrue );

        tentry.SetInPreparation( EFalse );

        tentry.SetUnread( isUnread );

        tentry.SetNew( isNew );

        tentry.SetComplete( ETrue );

        tentry.SetSendingState( KMsvSendStateWaiting );

        tentry.iServiceId = defaultServiceId;

        tentry.iRelatedId = 0;

        if ( folder == EInbox )

            {

            tentry.SetReadOnly( ETrue );

            }

        smsMtm->Entry().ChangeL( tentry );

        // send the message, if it is in outbox

        if ( folder == EOutbox )

            {

            CMsvEntrySelection* selection = new (ELeave) CMsvEntrySelection;

            CleanupStack::PushL( selection );

            selection->AppendL( tentry.Id() );

            TBuf8<1> dummyParameter;

            CMsvOperationWait* waiter = CMsvOperationWait::NewLC();

            CMsvOperation* op = smsMtm->InvokeAsyncFunctionL(

                    ESmsMtmCommandScheduleCopy, *selection,

                    dummyParameter, waiter->iStatus );

            CleanupStack::PushL( op );

            waiter->Start();

            CActiveScheduler::Start();

            CleanupStack::PopAndDestroy( op );

            CleanupStack::PopAndDestroy( waiter );

            CleanupStack::PopAndDestroy( selection );

            }

        CleanupStack::PopAndDestroy( smsMtm );

        CleanupStack::PopAndDestroy( body );

        CleanupStack::PopAndDestroy( description );

        CleanupStack::PopAndDestroy( fromTo );

        TInt32 id = tentry.Id();

        TBuf8<8> idStr;

        idStr.Copy( ( TUint8* )( &id ), sizeof( id ) );

        SendOkMsgL( idStr );

        }

    HTI_LOG_FUNC_OUT("CMessageMgmntHandler::HandleSmsImportFuncL: Done");

    }

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

void CMessageMgmntHandler::HandleCreateMmsL( const TDesC8& aData )

    {

    HTI_LOG_FUNC_IN( "CMessageMgmntHandler::HandleCreateMmsL" );

    if ( !ValidateAddMmsOrAddEmailCommand( aData ) )

        {

        // Error message has been sent from validation method.

        return;

        }

    // parse the parameters

    TInt position( 0 );

    TInt cmdCode = aData[position];

    position++;

    HBufC16* fromTo = ExtractDesLC( aData, position, 1 );

    HBufC16* description = ExtractDesLC( aData, position, 1 );

    HBufC8* body = NULL;

    if ( cmdCode == CHtiMessagesServicePlugin::EAddMms )

        {

        body = ExtractDes8LC( aData, position, 2 );

        }

    else // Audio msg does not have body text

        {

        body = HBufC8::NewLC( 0 );

        }

    HBufC16* attPath = ExtractDesLC( aData, position, 1 );

    TBool isNew = (TBool)aData[position];

    TBool isUnread = (TBool)aData[position+1];

    TFolder folder = (TFolder)aData[position+2];

    TInt extraAttNum;

    position += 3;

    TInt len = aData.Length();

    if( aData.Length() > position )

        {

        extraAttNum = (TInt)aData[position];

        }

    else

        {

        extraAttNum = 0;

        }

    position++;

    HTI_LOG_TEXT( "Creating MMS Client MTM" );

    CMmsClientMtm* mmsMtm = NULL;

    TRAPD( err , mmsMtm = ( CMmsClientMtm* )iMtmReg->NewMtmL(

            KUidMsgTypeMultimedia ) );

    if ( err || !mmsMtm )

        {

        HTI_LOG_TEXT( "MMS message type module not found" );

        SendErrorMessageL( KErrNotFound, KErrorMsgTypeNotFound );

        CleanupStack::PopAndDestroy( attPath );

        CleanupStack::PopAndDestroy( body );

        CleanupStack::PopAndDestroy( description );

        CleanupStack::PopAndDestroy( fromTo );

        return;

        }

    CleanupStack::PushL( mmsMtm );

    HTI_LOG_TEXT( "Creating MMS Client MTM" );

    CMsvEntry* entry = CMsvEntry::NewL( *iSession,

                                        KMsvGlobalInBoxIndexEntryId,

                                        TMsvSelectionOrdering() );

    CleanupStack::PushL( entry );

    // get the default service

    TMsvId defaultServiceId = 0;

    TRAP( err, defaultServiceId = mmsMtm->DefaultServiceL() );

    if ( err )

        {

        HTI_LOG_FORMAT( "Could not get default service, err: %d", err );

        SendErrorMessageL( err, KErrorMmsSettingNotDefined );

        CleanupStack::PopAndDestroy( entry );

        CleanupStack::PopAndDestroy( mmsMtm );

        CleanupStack::PopAndDestroy( attPath );

        CleanupStack::PopAndDestroy( body );

        CleanupStack::PopAndDestroy( description );

        CleanupStack::PopAndDestroy( fromTo );

        return;

        }

    // map the folder parameter to folder id

    TMsvId folderId = KMsvGlobalInBoxIndexEntryId;

    TRAP( err, folderId = MapFolderToIdL( folder ) );

    if ( err )

        {

        HTI_LOG_FORMAT( "Invalid folder: %d", folder );

        SendErrorMessageL( err, KErrorInvalidFolder );

        CleanupStack::PopAndDestroy( entry );

        CleanupStack::PopAndDestroy( mmsMtm );

        CleanupStack::PopAndDestroy( attPath );

        CleanupStack::PopAndDestroy( body );

        CleanupStack::PopAndDestroy( description );

        CleanupStack::PopAndDestroy( fromTo );

        return;

        }

    entry->SetEntryL( folderId );

    // mtm takes ownership of entry context

    mmsMtm->SetCurrentEntryL( entry );

    CleanupStack::Pop( entry );

    HTI_LOG_TEXT( "Creating MMS..." );

    mmsMtm->CreateMessageL( defaultServiceId );

    mmsMtm->SetMessageClass( EMmsClassPersonal );

    mmsMtm->SetExpiryInterval( 86400 );

    mmsMtm->SetDeliveryTimeInterval( 0 );

    mmsMtm->SetMessagePriority( EMmsPriorityNormal );

    mmsMtm->SetSenderVisibility( EMmsMaximumSenderVisibility );

    mmsMtm->SetDeliveryReport( EMmsDeliveryReportNo );

    mmsMtm->SetReadReply( EMmsReadReplyYes );

    if ( description->Length() > 0 )

        {

        mmsMtm->SetSubjectL( description->Des() );

        }

    if ( folder == EInbox )

        {

        mmsMtm->SetSenderL( fromTo->Des() );

        }

    else

        {

        mmsMtm->AddAddresseeL( fromTo->Des() );

        }

    // get an access to the message store

    HTI_LOG_TEXT( "Getting message store..." );

    CMsvStore* store = NULL;

    TRAP( err, store = entry->EditStoreL() );

    if ( err )

        {

        HTI_LOG_FORMAT( "Could not get access to message store, err: %d", err );

        SendErrorMessageL( err, KErrorMsgStoreOpenFailed );

        CleanupStack::PopAndDestroy( mmsMtm );

        CleanupStack::PopAndDestroy( attPath );

        CleanupStack::PopAndDestroy( body );

        CleanupStack::PopAndDestroy( description );

        CleanupStack::PopAndDestroy( fromTo );

        return;

        }

    CleanupStack::PushL( store );

    MMsvAttachmentManager& attachMan = store->AttachmentManagerL();

    // set body attachment only for normal MMS - audio message doesn't have body

    if ( cmdCode == CHtiMessagesServicePlugin::EAddMms )

        {

        // Set the message body as attachment

        // Use UTF-8 as charset because MMS created with MMS editor seems to

        // save text attachments also as UTF-8.

        HTI_LOG_TEXT( "Setting body..." );

        CMsvMimeHeaders* mimeHeaders = CMsvMimeHeaders::NewL();

        CleanupStack::PushL( mimeHeaders );

        mimeHeaders->SetContentTypeL( _L8( "text" ) );

        mimeHeaders->SetContentSubTypeL( _L8( "plain" ) );

        mimeHeaders->SetMimeCharset( KMmsUtf8 );

        mimeHeaders->SetSuggestedFilenameL( _L( "body.txt" ) );

        // ownership of bodyAttachment will be transferred

        CMsvAttachment* bodyAttachment = CMsvAttachment::NewL(

                CMsvAttachment::EMsvFile );

        CleanupStack::PushL( bodyAttachment );

        bodyAttachment->SetAttachmentNameL( _L( "body.txt" ) );

        bodyAttachment->SetMimeTypeL( _L8( "text/plain" ) );

        mimeHeaders->StoreL( *bodyAttachment );

        RFile textFile;

        CleanupClosePushL( textFile );

        CWaiter* waiter = CWaiter::NewLC();

        attachMan.CreateAttachmentL( _L( "body.txt" ), textFile,

                bodyAttachment, waiter->iStatus );

        waiter->StartAndWait();

        CleanupStack::PopAndDestroy( waiter );

        // write the UTF-8 body data to attachment file

        textFile.Write( *body );

        CleanupStack::PopAndDestroy(); // textFile

        CleanupStack::Pop( bodyAttachment ); // ownership transfered

        CleanupStack::PopAndDestroy( mimeHeaders );

        }