/*

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

*     Sms Ui Mtm.

*

*/

// INCLUDE FILES

// Specific includes

#include <SMUM.rsg>                     // resource ids

#include <etelmm.h>

#include <smuthdr.h>                    // for CSmsHeader

#include <smutset.h>                    // CSmsNumber

#include <smscmds.h>                    // TSmsMtmCommand

#include <aknViewAppUi.h>               // iAvkonViewAppUi

#include <MtmExtendedCapabilities.hrh>

// Standard includes

#include <txtrich.h>                    // CRichText

#include <aknnotewrappers.h>

// Comms includes

#include <MuiuMsgEditorLauncher.h>          // MsgEditorLauncher

#include <MsgBioUids.h>					 // KMsgBioUidPictureMsg

#include <akninputblock.h>			    // CAknInputBlock

#include <Muiumsginfo.h>                // CMsgInfoMessageInfoDialog

#include <MuiuOperationWait.h>              // MuiuOperationWait

// other includes

#include <StringLoader.h>               // StringLoader

#include <ErrorUI.h>                    // CErrorUI

#include <centralrepository.h>

#include <messaginginternalcrkeys.h>

#include <messagingvariant.hrh>

#include <BTSapDomainPSKeys.h>          // KPSUidBluetoothSapConnectionState, KBTSapConnectionState

#include <startupdomainpskeys.h>

#include <gmsModel.h>

#include <e32property.h>                // RProperty

#include <PSVariables.h>                // RProperty

#include <sacls.h>

#include <csmsaccount.h>

#include <csmsemailfields.h>            // CSmsEmailFields

// locals

#include "SmumSettingsDialogGSM.h"         // CSmumMainSettingsDialogGSM

#include "SmumUtil.h"                   // SmumUtil

#include "SMSU.HRH"                     // for KMtmUiFunctionSimDialog

#include "SMSU.H"                       // CSmsMtmUi

#include "smsui.pan"                    // panics

#include "simdlgplugininterface.h"

#include "BioOpenOp.h"					// CBioOpenOp

#include "MsgSimSCNumberDetector.h"     // CMsgSimOperation    

// Includes for fix to error SPAN-6B7K33

#include <rmmcustomapi.h>

#include <mmtsy_names.h>

//For logging

#include "SmumLogging.h"

//  LOCAL CONSTANTS AND MACROS

const TInt KMaxSubjectLength = 30;

const TInt KSmumAdditionalCharsStringLength = 7;

const TUint KSmumLRMarker = 0x200E;

const TUint KSmumChineseOffset = 8;

_LIT( KSmsuResourceFile, "SMUM" );

_LIT( KSmumSpace, " " );

_LIT( KSmumCharLeftAddressIterator, "<" );

_LIT( KSmumCharRightAddressIterator, ">" );

_LIT( KSmumCharCommaAndSpace, ", " );

_LIT( KSmumSmsService, "Sms Service" );

_LIT( KSmumChinaCountryCode, "+86");

_LIT( KSmumInternationalPrefix, "+");

// Default values, if shared data reading fails

const TInt KDefDeliveryReport = 1;

const TInt KDefValidityPeriod = 1440;

const TInt KDefMessageConversion = 0;

const TInt KDefPreferredConnection = 3;

const TInt KDefReplyViaSameCentre = 0;

// Constants for sms initialization

const TInt KInitializationReady = 2;

const TInt KInitializationReadSim = 3;

//  MEMBER FUNCTIONS

// Factory constructor function

CSmsMtmUi* CSmsMtmUi::NewL( CBaseMtm& aBaseMtm, CRegisteredMtmDll& aRegisteredMtmDll )

    {

    SMUMLOGGER_ENTERFN(" CSmsMtmUi::NewL");

    CSmsMtmUi* smsmtmui=new ( ELeave ) CSmsMtmUi( aBaseMtm, aRegisteredMtmDll );

    CleanupStack::PushL( smsmtmui );

    smsmtmui->ConstructL();

    CleanupStack::Pop();

    SMUMLOGGER_LEAVEFN(" CSmsMtmUi::NewL");

    return smsmtmui;

    }

// C++ constructor can NOT contain any code, that

// might leave.

CSmsMtmUi::CSmsMtmUi( CBaseMtm& aBaseMtm, CRegisteredMtmDll& aRegisteredMtmDll ):

    CBaseMtmUi( aBaseMtm, aRegisteredMtmDll )

    {

    }

// Symbian OS default constructor can leave.

void CSmsMtmUi::ConstructL()

    {

    SMUMLOGGER_ENTERFN(" CSmsMtmUi::ConstructL");

    CBaseMtmUi::ConstructL();

	TInt err( KErrGeneral );

	// connect etel server

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

    // load tsy

    err = iServer.LoadPhoneModule( KMmTsyModuleName );

    if ( err != KErrAlreadyExists )

        {

        // may return also KErrAlreadyExists if some other

        // is already loaded the tsy module. And that is

        // not an error.

        User::LeaveIfError( err );

        }

	User::LeaveIfError( iPhone.Open( iServer, KMmTsyPhoneName ) );

    // Error resolver

    iErrorResolver = CTextResolver::NewL( *iCoeEnv );

    // Create the session

    iCenRepSession = CRepository::NewL( KCRUidSmum );

	// create sim-dialog plugin interface

    iSimDlgPluginIntf = CSimDlgPluginInterface::NewL(*this, Session());    

    SMUMLOGGER_LEAVEFN(" CSmsMtmUi::ConstructL");

    }

// Destructor

CSmsMtmUi::~CSmsMtmUi()

    {

    SMUMLOGGER_ENTERFN(" CSmsMtmUi::~CSmsMtmUi");

    //close ETel connection

    if (iServer.Handle())

        {

        iPhone.Close();           

        iServer.UnloadPhoneModule(KMmTsyModuleName);

        iServer.Close();

        }

    delete iErrorResolver;

    delete iCenRepSession;

    delete iSimDlgPluginIntf;

    SMUMLOGGER_LEAVEFN(" CSmsMtmUi::~CSmsMtmUi");

    }

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

// CSmsMtmUi::CreateL

//

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

CMsvOperation* CSmsMtmUi::CreateL(const TMsvEntry& aEntry, CMsvEntry& aParent, TRequestStatus& aStatus)

    {

    SMUMLOGGER_ENTERFN(" CSmsMtmUi::CreateL");

    //    Create a Sms message (services are provided "for nothing", created invisibly by the UI layer.

    __ASSERT_DEBUG( aEntry.iMtm == Type(), Panic( ESmsuWrongMtmType ));

    __ASSERT_DEBUG( aEntry.iType == KUidMsvMessageEntry, Panic( ESmsuNotAMessage ));

    __ASSERT_DEBUG( aParent.Entry().iServiceId == KMsvLocalServiceIndexEntryId ||

        aParent.Entry().iServiceId == KMsvNullIndexEntryId, Panic( ESmsuMessageNotLocal ));

    __ASSERT_DEBUG(( aParent.Entry().iType == KUidMsvFolderEntry &&

        aParent.Entry().iServiceId == KMsvLocalServiceIndexEntryId), 

        Panic( ESmsuMessageParentNotLocalFolder ));

    if( !CheckEntry( aEntry ))

        {

        User::Leave( KErrNotSupported );    //    Not SMS, or not a message

        }

    CheckAndEnsureSmsServiceOkL( ETrue, ETrue, ETrue );

    SMUMLOGGER_LEAVEFN(" CSmsMtmUi::CreateL");

    return LaunchEditorApplicationL( aStatus, aParent.Session(), ECreateNewMessage );

    }

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

// CSmsMtmUi::OpenL

//

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

CMsvOperation* CSmsMtmUi::OpenL(TRequestStatus& aStatus)

    {

    SMUMLOGGER_ENTERFN(" CSmsMtmUi::OpenL");

    __ASSERT_DEBUG( 

        BaseMtm().Entry().Entry().iMtm == Type(), Panic( ESmsuWrongMtmType ));

    __ASSERT_DEBUG( BaseMtm().Entry().Entry().iType != 

        KUidMsvFolderEntry, Panic( ESmsuFoldersNotSupported ));

    __ASSERT_DEBUG( BaseMtm().Entry().Entry().iType != KUidMsvAttachmentEntry, 

        Panic( ESmsuAttachmentsNotSupported ));

    const TMsvEntry myEntry = BaseMtm().Entry().Entry();

    if( myEntry.iType == KUidMsvFolderEntry || myEntry.iType == KUidMsvAttachmentEntry )

        {

        User::Leave(KErrNotSupported);

        }

    else if ( myEntry.iType == KUidMsvMessageEntry )

        {

        CheckAndEnsureSmsServiceOkL( ETrue, ETrue, ETrue );

        }

    else // Lint

        {

        }

    CSmsClientMtm& smsClientMtm = SmsClientMtm();

    smsClientMtm.LoadMessageL();

    const CSmsPDU::TSmsPDUType pduType = smsClientMtm.SmsHeader().Type();

    CSmsPDU& pdu = smsClientMtm.SmsHeader().Message().SmsPDU();

    TSmsDataCodingScheme::TSmsClass smsClass;

    pdu.Class( smsClass );

    /* 

    Fix to error SPAN-6B7K33

    In case this happens to be an unread message stored on sim, 

    TSY sets the status of the message to 'read' on the sim also.

    */

    if( pduType == CSmsPDU::ESmsDeliver && 

            smsClass == TSmsDataCodingScheme::ESmsClass2)

        {

        CSmsDeliver& deliv = smsClientMtm.SmsHeader().Deliver();

        TTime scTime;

        TInt scQh;

        deliv.ServiceCenterTimeStamp(scTime, scQh);

        RMmCustomAPI ca;

        if ( KErrNone == ca.Open( iPhone ) )

            {

            ca.SetSimMessageStatusRead( scTime, scQh );

            ca.Close();

            }

        }

    // Check are we dealing with delivery raport	

    // No support for 8-bit non GMS messages

    if ( !(pduType == CSmsPDU::ESmsDeliver || pduType == CSmsPDU::ESmsSubmit) || 

        ( pdu.Alphabet() == TSmsDataCodingScheme::ESmsAlphabet8Bit && !IsBioTypeSupported( myEntry ) ) )

        {

        if ( myEntry.Unread() )

            {

            // Mark the entry as read

            CMsvEntry* cEntry = &(BaseMtm().Entry());

            TMsvEntry entry = cEntry->Entry();

            entry.SetUnread( EFalse );

            cEntry->ChangeL( entry );

            }

        TSmsSmumProgress progress;

        progress.iError = KErrNotSupported;

        progress.iType = TSmsSmumProgress::ESmsSmumSmsOpening;

        TSmsSmumProgressBuf progressBuf( progress );

        SMUMLOGGER_ENTERFN(" CSmsMtmUi::OpenL - completedOp");

        return CMsvCompletedOperation::NewL(

            Session(), 

            Type(), 

            progressBuf, 

            KMsvLocalServiceIndexEntryId, 

            aStatus, 

            KErrNotSupported );

        }

    if (KMsvDraftEntryIdValue == myEntry.Parent())

        {

        SMUMLOGGER_ENTERFN(" CSmsMtmUi::OpenL- EditL");

        return EditL( aStatus );

        }

    else

        {

        SMUMLOGGER_ENTERFN(" CSmsMtmUi::OpenL- viewL");

        return ViewL( aStatus );

        }

    }

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

// CSmsMtmUi::CloseL

//

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

CMsvOperation* CSmsMtmUi::CloseL(TRequestStatus& /*aStatus*/)

    {

    SMUMLOGGER_ENTERFN(" CSmsMtmUi::CloseL");

    User::Leave( KErrNotSupported );

    SMUMLOGGER_LEAVEFN(" CSmsMtmUi::CloseL");

    return NULL;

    }

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

// CSmsMtmUi::EditL

//

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

CMsvOperation* CSmsMtmUi::EditL( TRequestStatus& aStatus ) 

    {

    SMUMLOGGER_ENTERFN(" CSmsMtmUi::EditL");

    __ASSERT_DEBUG( BaseMtm().Entry().Entry().iMtm == 

        Type(), Panic( ESmsuWrongMtmType ));

    CMsvOperation* msvoperation = NULL;

    if( BaseMtm().Entry().Entry().iBioType != 0 )

        { // BIO msg

        msvoperation = CBioOpenOp::NewL( 

            Session(),

            aStatus,

            BaseMtm().Entry().EntryId(), 

            Preferences());

        }

    else

        { // not BIO msg

        // What kind of entry are we going to edit?

        switch ( iBaseMtm.Entry().Entry().iType.iUid )

            {

            case KUidMsvServiceEntryValue:

                CheckAndEnsureSmsServiceOkL( ETrue, ETrue, ETrue );

                msvoperation = LaunchSettingsDialogL( aStatus );

                break;

            case KUidMsvMessageEntryValue:

                if ( BaseMtm().Entry().Entry().ReadOnly() )

                    {

                    User::Leave(KErrAccessDenied);

                    }

                msvoperation = LaunchEditorApplicationL( aStatus, iBaseMtm.Entry().Session());

                break;

            case KUidMsvFolderEntryValue:

            case KUidMsvAttachmentEntryValue:

            default:

            #if defined( _DEBUG )

                Panic( ESmsuWrongEntryType );

            #else

                User::Leave( KErrNotSupported );

            #endif

            }   

        }

    SMUMLOGGER_LEAVEFN(" CSmsMtmUi::EditL");

    return msvoperation;

    }

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

// CSmsMtmUi::ViewL

//

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

CMsvOperation* CSmsMtmUi::ViewL( TRequestStatus& aStatus )

    {

    SMUMLOGGER_ENTERFN(" CSmsMtmUi::ViewL");

     __ASSERT_DEBUG( BaseMtm().Entry().Entry().iMtm == Type(), 

         Panic( EBioViewNotAllowed ));

    CMsvOperation* msvoperation = NULL;

    if( iBaseMtm.Entry().Entry().iType.iUid == KUidMsvMessageEntryValue )

        {

        msvoperation = LaunchEditorApplicationL( aStatus, iBaseMtm.Entry().Session(), EReadOnly);

        }

    else

        {

        #if defined( _DEBUG )

            Panic( ESmsuWrongEntryType );

            #else

            User::Leave( KErrNotSupported );

            #endif        

        }

    SMUMLOGGER_LEAVEFN(" CSmsMtmUi::ViewL");

    return msvoperation;

    }

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

// CSmsMtmUi::OpenL

//

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

CMsvOperation* CSmsMtmUi::OpenL( TRequestStatus& aStatus, const CMsvEntrySelection& aSelection )

    {

    SMUMLOGGER_ENTERFN(" CSmsMtmUi::OpenL");

    __ASSERT_DEBUG( aSelection.Count() > 0, Panic( ESmsuEmptySelection ));

    //    Open the first entry in the selection

    BaseMtm().SwitchCurrentEntryL( aSelection[0] );

    SMUMLOGGER_LEAVEFN(" CSmsMtmUi::OpenL");

    return OpenL( aStatus );

    }

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

// CSmsMtmUi::CloseL

//

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

CMsvOperation* CSmsMtmUi::CloseL( TRequestStatus& /*aStatus*/, const CMsvEntrySelection& /*aSelection*/ )

    {

    SMUMLOGGER_WRITE(" CSmsMtmUi::CloseL");

    User::Leave( KErrNotSupported );

    return NULL;

    }

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

// CSmsMtmUi::EditL

//

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

CMsvOperation* CSmsMtmUi::EditL( TRequestStatus& aStatus, const CMsvEntrySelection& aSelection )  

    {

    SMUMLOGGER_ENTERFN(" CSmsMtmUi::EditL - AGAIN");

    __ASSERT_ALWAYS( aSelection.Count() > 0 , Panic( ESmsuEmptySelection ));

    //    Edit the first entry in the selection

    BaseMtm().SwitchCurrentEntryL( aSelection[0] );

    SMUMLOGGER_LEAVEFN(" CSmsMtmUi::EditL - AGAIN");

    return EditL( aStatus );

    }

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

// CSmsMtmUi::ViewL

//

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

CMsvOperation* CSmsMtmUi::ViewL( TRequestStatus& aStatus, const CMsvEntrySelection& aSelection )

    {

    SMUMLOGGER_ENTERFN(" CSmsMtmUi::ViewL - AGAIN");

    __ASSERT_DEBUG( aSelection.Count() > 0, Panic( ESmsuEmptySelection ));

    //    View the first entry in the selection

    BaseMtm().SwitchCurrentEntryL( aSelection[0] );

    SMUMLOGGER_LEAVEFN(" CSmsMtmUi::ViewL - AGAIN");

    return ViewL( aStatus );

    }

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

// CSmsMtmUi::CancelL

//

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

CMsvOperation* CSmsMtmUi::CancelL( TRequestStatus& aStatus, const CMsvEntrySelection& aSelection )

    {

    SMUMLOGGER_ENTERFN(" CSmsMtmUi::CancelL");

    TInt loop = aSelection.Count();

    __ASSERT_DEBUG( loop > 0, Panic( ESmsuEmptySelection ));

    CMsvEntry* entry = Session().GetEntryL( aSelection[0] );

    CleanupStack::PushL( entry );

    while ( loop-- )

        {

        entry->SetEntryL( aSelection[loop] );

        TMsvEntry tempEntry = entry->Entry();

        tempEntry.SetSendingState( KMsvSendStateSuspended );

        tempEntry.iDate.UniversalTime();

        tempEntry.iRelatedId = tempEntry.iServiceId;

        tempEntry.iServiceId = KMsvLocalServiceIndexEntryId;

        entry->ChangeL( tempEntry );

        }

    CleanupStack::PopAndDestroy();// entry

    TSmsProgressBuf progress;

    Session().ServiceProgress( SmsClientMtm().ServiceId(), progress ); //ignore error

    TBuf8<1> dummy;

    dummy.Zero();

    SMUMLOGGER_LEAVEFN(" CSmsMtmUi::CancelL");

    return CBaseMtmUi::InvokeAsyncFunctionL( ESmsMtmCommandDeleteSchedule, aSelection, aStatus, dummy );

    }

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

// CSmsMtmUi::DeleteFromL

//

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

CMsvOperation* CSmsMtmUi::DeleteFromL( const CMsvEntrySelection& /*aSelection*/, TRequestStatus& /*aStatus*/ )

    {

    SMUMLOGGER_WRITE(" CSmsMtmUi::DeleteFromL");

    User::Leave( KErrNotSupported );

    return NULL;

    }

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

// CSmsMtmUi::DeleteServiceL

//

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

CMsvOperation* CSmsMtmUi::DeleteServiceL( const TMsvEntry& /*aService*/, TRequestStatus& /*aStatus*/ )

    {

    SMUMLOGGER_WRITE(" CSmsMtmUi::DeleteServiceL");

    User::Leave( KErrNotSupported );

    return NULL;

    }

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

// CSmsMtmUi::ReplyL

//

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

CMsvOperation* CSmsMtmUi::ReplyL( 

    TMsvId aDestination, 

    TMsvPartList /*aPartlist*/, 

    TRequestStatus& aCompletionStatus )

    {

    SMUMLOGGER_ENTERFN(" CSmsMtmUi::ReplyL");

    CheckAndEnsureSmsServiceOkL( ETrue, ETrue, ETrue );

    // Set params

    TEditorParameters editorParams;

    editorParams.iFlags |= EMsgReplyToMessageSender;

    editorParams.iId = BaseMtm().Entry().EntryId();

    editorParams.iDestinationFolderId = aDestination; 

	editorParams.iFlags &=~ ( EMtmUiFlagEditorPreferEmbedded | EMtmUiFlagEditorNoWaitForExit );

	editorParams.iFlags |= ( Preferences() & EMtmUiFlagEditorPreferEmbedded ? EMsgLaunchEditorEmbedded : 0 );

	editorParams.iFlags |= ( Preferences() & EMtmUiFlagEditorNoWaitForExit ? 0 : EMsgLaunchEditorThenWait );

    SMUMLOGGER_LEAVEFN(" CSmsMtmUi::ReplyL");

    return MsgEditorLauncher::LaunchEditorApplicationL(Session(), Type(), aCompletionStatus, editorParams, KNullDesC /*, paramPack*/);

    }

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

// CSmsMtmUi::ForwardL

//

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

CMsvOperation* CSmsMtmUi::ForwardL(

    TMsvId aDestination, 

    TMsvPartList /*aPartList*/, 

    TRequestStatus& aCompletionStatus )

    {

    SMUMLOGGER_ENTERFN(" CSmsMtmUi::ForwardL");