/*

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

*       Provides Notification MTM UI methods.

*

*/

// INCLUDE FILES

//Features

#include <featmgr.h>    

#include <bldvariant.hrh>

#include <MuiuMsvProgressReporterOperation.h> // CMsvProgressReporterOperation

#include <mtudreg.h>                 // MTM UI data registry

#include <mtudcbas.h>                // MTM UI data base

#include "NotMtmUi.h"

#include <apgcli.h>

#include <msvuids.h>

#include <mtmuidef.hrh>

#include <e32keys.h>

#include <coemain.h>

#include <eikenv.h>

#include <eikdef.h>

#include <eikmfne.h>

#include <eikedwin.h>

#include <eikcapc.h>

#include <gulicon.h>

#include <ErrorUI.h> //CErrorUI

#include <aknnotewrappers.h>                // CAknInformationNote

#include <aknPopup.h>

#include <aknlists.h>

#include <aknconsts.h>

#include <akncontext.h>

#include <akntabgrp.h>

#include <AknQueryDialog.h>

#include <StringLoader.h>               // link against CommonEngine.lib

#include <Muiumsginfo.h>

#include <MuiuMsvUiServiceUtilities.h>

#include <muiumsvuiserviceutilitiesinternal.h>

#include <akninputblock.h>              // CAknInputBlock

#include <MtmExtendedCapabilities.hrh>

#include <messagingvariant.hrh>

#include <centralrepository.h>    // link against centralrepository.lib

#include <messaginginternalcrkeys.h> // for Central Repository keys

#include <CoreApplicationUIsSDKCRKeys.h>

#include <ApUtils.h> //CApUtils, CCommsDatabase, EDatabaseTypeIAP

#include <NotUi.rsg>

#include <mmserrors.h>

#include "NotMtmUiPanic.h"

#include <mmsconst.h>

#include <mmscmds.h>    // EMmsDeleteSchedule

#include <mmsmsventry.h>

#include <mmsnotificationclient.h>

#include <mmsgenutils.h>

#include <mmssettings.h> // MMS Engine settings

#include "MmsMtmConst.h"

#include "MMBoxDialog.h"

#include "NotMtmUiData.h"

// CONSTANTS

_LIT( KAddressSeparator,", " );

_LIT( KCharLeftAddressIterator, "<" );

_LIT( KCharRightAddressIterator, ">" );

_LIT( KMmsCharCommaAndSpace, ", " );

_LIT( KMmsCharSpace, " " );

const TInt KMessageSize = 20;

const TInt KZero = 0; //constant for memory check

const TInt KMmsAdditionalCharsStringLength = 7;

const TUint KMmsLRMarker = 0x200E;

const TUid KUidUniEditor = {0x102072D8};

#define IS_PHONE_OFF_LINEL() MsvUiServiceUtilitiesInternal::IsPhoneOfflineL()

// MACROS

#define iMmsClient  ( static_cast<CMmsNotificationClientMtm&>( iBaseMtm ) )

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

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

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

// NewNotMtmUiL

// Factory function

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

//

EXPORT_C CBaseMtmUi* NewNotMtmUiL( CBaseMtm& aMtm, CRegisteredMtmDll& aRegisteredDll )

    {

    return CNotMtmUi::NewL( aMtm, aRegisteredDll );

    }

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

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

// CNotMtmUi::CNotMtmUi

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

// might leave.

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

//

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

    :   CBaseMtmUi( aBaseMtm, aRegisteredMtmDll )

    {

    }

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

// CNotMtmUi::ConstructL

// Symbian OS default constructor can leave.

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

//

void CNotMtmUi::ConstructL()

    {

    LOGTEXT(_L8("NotMtmUi: Construct start"));

    CBaseMtmUi::ConstructL();

    iSettingsHandler = CMmsSettingsHandler::NewL( iMmsClient );

    TInt featureBitmask = 0;

    CRepository* repository = CRepository::NewL( KCRUidMuiuVariation );

    repository->Get( KMuiuMmsFeatures, featureBitmask );

    delete repository;

    repository = NULL;

    if ( featureBitmask & KMmsFeatureIdDeleteOptions )

        {

        iNotUiFlags |= EDeleteOptionsSupported;

        }

    featureBitmask = 0;

    FeatureManager::InitializeLibL();

    if ( FeatureManager::FeatureSupported( KFeatureIdOfflineMode ) )

        {

        iNotUiFlags |= EOffline;

        }

    FeatureManager::UnInitializeLib();

    LOGTEXT(_L8("NotMtmUi: Construct end"));

    }

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

// CNotMtmUi::NewL

// Two-phased constructor.

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

// 

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

    {

    LOGTEXT( _L8( "NotMtmUi::NewL" ) );

    CNotMtmUi* self = new ( ELeave ) CNotMtmUi( aBaseMtm, aRegisteredMtmDll );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CNotMtmUi::~CNotMtmUi

// Destructor

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

//

CNotMtmUi::~CNotMtmUi()

    {

    delete iSettingsHandler;

    delete iWaitDialog;

    }

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

// CNotMtmUi::QueryCapability

// Capability check for UI mtm specific functionality. These should

// be minimal, as the default capability checking places are UI data MTM

// (UI) and client MTM (engine).

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

TInt CNotMtmUi::QueryCapability( TUid aCapability, TInt& aResponse )

    {

    switch ( aCapability.iUid )

        {

        case KUidMsvMtmUiQueryMessagingInitialisation: // flow through

        case KUidMsvMtmQueryFactorySettings:

        case KUidMsvMtmQuerySupportValidateService:

            aResponse = ETrue;

            return KErrNone;

        default:

            // Actually this routes to client MTM capability check.

            return CBaseMtmUi::QueryCapability( aCapability, aResponse );

        }

    }

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

// CNotMtmUi::CreateL

// Not supported.

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

//

CMsvOperation* CNotMtmUi::CreateL( const TMsvEntry& /*aEntry*/, 

                                  CMsvEntry& /*aParent*/, 

                                  TRequestStatus& /*aStatus*/ )

    {

    User::Leave( KErrNotSupported );

    return NULL;

    }

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

// CNotMtmUi::CheckSettingsL() const

// Check MMS service settings

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

//

EXPORT_C TBool CNotMtmUi::CheckSettingsL( CMmsSettingsDialog::TMmsExitCode& aExitCode ) const

    {

    // First reload the settings

    iSettingsHandler->RefreshSettingsL( );

    return iSettingsHandler->CheckSettingsL( aExitCode );

    }

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

// CNotMtmUi::DeleteServiceL

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

//

CMsvOperation* CNotMtmUi::DeleteServiceL( const TMsvEntry& /*aService*/, 

                                         TRequestStatus& /*aStatus*/ )

    {

    User::Leave( KErrNotSupported );

    return NULL;

    }

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

// CNotMtmUi::DeleteFromL

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

//

CMsvOperation* CNotMtmUi::DeleteFromL( const CMsvEntrySelection& /*aSelection*/, 

                                      TRequestStatus& /*aStatus*/ )

    {

    User::Leave( KErrNotSupported );

    return NULL;

    }

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

// CMmsMtmUi::CopyToL

// Copy local outbox entry to remote server = called when sending the entry from MCE outbox

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

//

CMsvOperation* CNotMtmUi::CopyToL( const CMsvEntrySelection& aSelection, 

                                  TRequestStatus& aStatus )

    {

    return CopyMoveToL( aSelection, aStatus, ETrue );

    }

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

// CNotMtmUi::MoveToL

// Move local outbox entry to remote server.

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

//

CMsvOperation* CNotMtmUi::MoveToL( const CMsvEntrySelection& aSelection, 

                                  TRequestStatus& aStatus )

    {

    return CopyMoveToL( aSelection, aStatus, EFalse );

    }

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

// CNotMtmUi::CopyMoveToL

// Performs either CopyToL or MoveToL operation.

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

//

CMsvOperation* CNotMtmUi::CopyMoveToL( const CMsvEntrySelection& aSelection, 

                                      TRequestStatus& aStatus, TBool aCopyOnly )

    {

    __ASSERT_DEBUG( iBaseMtm.Entry().Entry().iMtm==Type(), Panic( EMmsWrongMtm ) );

    __ASSERT_DEBUG( iBaseMtm.Entry().Entry().iType==KUidMsvServiceEntry, Panic( EMmsNotAService ) );

    // --- Carry out the operation ---

    TMsvEntry mmsService ( BaseMtm().Entry().Entry() );

    //    Get CMsvEntry of parent of messages to be sent

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

    CleanupStack::PushL( parentEntry );

    parentEntry->SetEntryL( parentEntry->Entry().Parent() );

    // Do the copy/move

    CMsvOperation* op = aCopyOnly ?

        parentEntry->CopyL( aSelection, mmsService.Id(), aStatus ) :

        parentEntry->MoveL( aSelection, mmsService.Id(), aStatus );

    CleanupStack::PopAndDestroy();    //parentEntry

    return op;

    }

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

// CNotMtmUi::CopyFromL

// Could be used in fetching messages manually, but client MTM API has simple FetchL()

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

//

CMsvOperation* CNotMtmUi::CopyFromL(const CMsvEntrySelection& /*aSelection*/, 

                                    TMsvId /*aTargetId*/, 

                                    TRequestStatus& /*aStatus*/)

    {

    User::Leave( KErrNotSupported );

    return NULL;

    }

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

// CNotMtmUi::MoveFromL

// Could be used in fetching messages manually, but client MTM API has simple FetchL()

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

//

CMsvOperation* CNotMtmUi::MoveFromL(const CMsvEntrySelection& /*aSelection*/, 

                                    TMsvId /*aTargetId*/, 

                                    TRequestStatus& /*aStatus*/)

    {

    User::Leave( KErrNotSupported );

    return NULL;

    }

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

// CNotMtmUi::OpenL

// Handles request to open existing message server entry (message/service)

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

//

CMsvOperation* CNotMtmUi::OpenL( TRequestStatus& aStatus )

    {

    LOGTEXT(_L8("NotMtmUi: OpenL start"));

    __ASSERT_DEBUG( iBaseMtm.Entry().Entry().iMtm==Type(), Panic( EMmsWrongMtm ) );

    const TMsvEntry& entry = BaseMtm().Entry().Entry();

    if ( entry.ReadOnly() )

        {

        return ViewL( aStatus );

        }

    else

        {

        return EditL( aStatus );

        }

    }

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

// CNotMtmUi::OpenL

// Opens the first entry in a selection

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

//

CMsvOperation* CNotMtmUi::OpenL( TRequestStatus& aStatus, 

                                const CMsvEntrySelection& aSelection )

    {

    LOGTEXT(_L8("NotMtmUi: OpenL start"));

    __ASSERT_DEBUG( iBaseMtm.Entry().Entry().iMtm==Type(), Panic( EMmsWrongMtm ) );

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

    return OpenL( aStatus );

    }

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

// CNotMtmUi::CloseL

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

//

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

    {

    User::Leave( KErrNotSupported );

    return NULL;

    }

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

// CNotMtmUi::CloseL

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

//

CMsvOperation* CNotMtmUi::CloseL( TRequestStatus& /*aStatus*/, 

                                 const CMsvEntrySelection& /*aSelection*/ )

    {

    User::Leave( KErrNotSupported );

    return NULL;

    }

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

// CNotMtmUi::EditL

// Opens a message (editor) or service (settings dialog) for editing.

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

//

CMsvOperation* CNotMtmUi::EditL( TRequestStatus& aStatus )

    {

    LOGTEXT(_L8("NotMtmUi::EditL start"));

    __ASSERT_DEBUG( iBaseMtm.Entry().Entry().iMtm==Type(), Panic( EMmsWrongMtm ) );

    CMsvOperation* msvoperation = NULL;

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

        {

        case KUidMsvMessageEntryValue:

            {

            CMmsSettingsDialog::TMmsExitCode exitCode = 

                CMmsSettingsDialog::EMmsExternalInterrupt;

            if( MsvUiServiceUtilities::DiskSpaceBelowCriticalLevelL(

                Session(),

                KZero ) )

                {

                User::Leave( KErrDiskFull );

                }

            if ( !CheckSettingsL( exitCode ) ) 

                {

                TInt32 ap = iSettingsHandler->MmsSettings()->AccessPoint( 0 );

                //settings saved with valid access point

                if( !( exitCode==CMmsSettingsDialog::EMmsBack && ApExistsL( ap ) ) )

                    {

                    return CompleteSettingsOperationL( aStatus, exitCode );

                    }

                }

            if ( iBaseMtm.Entry().Entry().Connected() )

                {

                User::Leave( KErrLocked ); 

                }

            LOGTEXT( _L8( "NotMtmUi::EditL launching editor" ) );

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

            }

            break;

        case KUidMsvServiceEntryValue:

            LOGTEXT( _L8( "NotMtmUi::EditL - launching settings" ) );

            msvoperation = OpenServiceSettingsDialogL( aStatus );

            break;

        case KUidMsvAttachmentEntryValue:   // flow through

        case KUidMsvFolderEntryValue:       // flow through

        default:

            User::Leave( KErrNotSupported );

            break;

        }

    return msvoperation;

    }

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

// CNotMtmUi::EditL

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

//

CMsvOperation* CNotMtmUi::EditL( TRequestStatus& aStatus, 

                                const CMsvEntrySelection& aSelection )

    {

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

    return EditL( aStatus );

    }

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

// CNotMtmUi::ViewL

// Opens the message for reading in Viewer.

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

//

CMsvOperation* CNotMtmUi::ViewL( TRequestStatus& aStatus )

    {

    LOGTEXT( _L8( "NotMtmUi::ViewL" ) );

    __ASSERT_DEBUG( iBaseMtm.Entry().Entry().iMtm == Type(), Panic( EMmsWrongMtm ) );

    CMsvOperation* msvoperation = NULL;

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

        {

        case KUidMsvMessageEntryValue:

            // It's a multimedia message

            if ( iBaseMtm.Entry().Entry().Connected() )

                {

                User::Leave( KErrLocked );

                }

            // Open Viewer

            LOGTEXT( _L8( "NotMtmUi::ViewL - launching Viewer" ) );

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

            break;

        case KUidMsvServiceEntryValue:

        case KUidMsvAttachmentEntryValue:

        case KUidMsvFolderEntryValue:

        default:

            User::Leave( KErrNotSupported );

            break;

        }

    return msvoperation; 

    }

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

// CNotMtmUi::ViewL

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

//

CMsvOperation* CNotMtmUi::ViewL( TRequestStatus& aStatus, 

                                const CMsvEntrySelection& aSelection )

    {

    __ASSERT_DEBUG( iBaseMtm.Entry().Entry().iMtm == Type(), Panic( EMmsWrongMtm ) );

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

    return ViewL( aStatus );

    }

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

// CNotMtmUi::LaunchEditorApplicationL()

// Does the actual opening.

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

//

CMsvOperation* CNotMtmUi::LaunchEditorApplicationL( TRequestStatus& aStatus, 

                                                   CMsvSession& aSession, 

                                                   TEditorType aEditorType )

    {

    LOGTEXT(_L8("NotMtmUi: LaunchEditorApplicationL start"));

    TEditorParameters temp;    

    if ( iBaseMtm.HasContext() )