/*

* 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 data methods.

*

*/

// INCLUDE FILES

#include "NotMtmUiData.h"

#include <mtclbase.h>

#include <eikon.rsg>

#include <data_caging_path_literals.hrh> 

#include <coemain.h>

#include <AknsUtils.h>

#include <AknsConstants.h>

#include <mtmuids.h>

#include <msvids.h>

#include <msvuids.h>

#include <mtmuidef.hrh>

#include <NotUi.rsg>

#include <muiu.mbg>                         // for notif icon bitmaps

#include <messagingvariant.hrh>

#include <avkon.rsg>

#include "NotMtmUiPanic.h"

#include "MmsMtmConst.h"

#include <mmserrors.h>

#include <mmsconst.h>                       // for KUidMsgTypeMultimedia

#include <featmgr.h>  

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

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

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

// CONSTANTS

const TInt KMmsReadIconIndex = 0;

const TInt KMmsUnreadIconIndex = 1;

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

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

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

// NewNotMtmUiDataL

// Factory function

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

//

EXPORT_C CBaseMtmUiData* NewNotMtmUiDataL( CRegisteredMtmDll& aRegisteredDll )

    {

    return CNotMtmUiData::NewL( aRegisteredDll );

    }

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

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

// CNotMtmUiData::CMmsMtmUiData

// C++ constructor

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

//

CNotMtmUiData::CNotMtmUiData( CRegisteredMtmDll& aRegisteredDll )

    :   CBaseMtmUiData( aRegisteredDll )

    {

    }

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

// CNotMtmUiData::ConstructL

// Symbian OS default constructor can leave.

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

//

void CNotMtmUiData::ConstructL()

    {

    // KFeatureIdMMSNotificationsView is needed in CNotMtmUiData::PopulateArraysL,

    // which is called from CBaseMtmUiData::ConstructL();

    // Get supported features from feature manager.

    FeatureManager::InitializeLibL();

    // KFeatureIdMmsNonDestructiveForward has been deprecated

    // Check of TMsvEntry::iMtmData2 & KMmsStoredInMMBox replaces it. 

    // MMSEngine sets KMmsStoredInMMBox for received notifications

    if ( FeatureManager::FeatureSupported( KFeatureIdMMSNotificationsView ) )

        {

        iNotUiDataFlags |= ENotificationsViewInMce;

        }

    FeatureManager::UnInitializeLib();

    CBaseMtmUiData::ConstructL();

    //  Get mms local variation values

    TInt featureBitmask = 0;

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

    repository->Get( KMuiuMmsFeatures, featureBitmask );

    delete repository;

    repository = NULL;

    if ( featureBitmask & KMmsFeatureIdNotificationForward )

        {

        iNotUiDataFlags |= EForwardSupported;

        }

    featureBitmask = 0;

    }

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

// CNotMtmUiData::NewL

// Two-phased constructor.

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

//

CNotMtmUiData* CNotMtmUiData::NewL( CRegisteredMtmDll& aRegisteredDll )

    {

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

    CNotMtmUiData* self = new ( ELeave ) CNotMtmUiData( aRegisteredDll );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop(); //self

    return self;

    }

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

// CNotMtmUiData::~CMmsMtmUiData

// Destructor.

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

//

CNotMtmUiData::~CNotMtmUiData()

    {

    }

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

// CNotMtmUiData::OperationSupportedL

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

//

TInt CNotMtmUiData::OperationSupportedL(

    TInt aFunctionId,

    const TMsvEntry& aContext ) const

    {

    LOGTEXT2( _L16( "NotMtmUiData - OperationSupported: %d" ), aContext.Id() ); 

    if( ( aContext.iMtmData1 & KMmsMessageTypeMask ) == KMmsMessageMNotificationInd ) // Notification

        {

        TNotUiMsgStatus msgstatus = MsgStatus( aContext );

        // Only Message Info for messages is a supported operation

        if ( ( aFunctionId == KMtmUiFunctionMessageInfo ) &&

            ( aContext.iType == KUidMsvMessageEntry ) )

            {   // Info is always supported for messages

            LOGTEXT( _L8( "NotMtmUiData - Operation Message Info supported" ) );

            return 0;

            }

        if ( ( aFunctionId == KMtmUiFunctionFetchMMS ) &&

            ( aContext.iType == KUidMsvMessageEntry ) )

            {

            if( aContext.iMtmData2 & KMmsNewOperationForbidden ) // New Forbidden

                {

                LOGTEXT( _L8( "NotMtmUiData - Operation Retrieve not supported" ) );

                return R_EIK_TBUF_NOT_AVAILABLE;

                }

            // If notification is succesfully routed to app 

            // aContext.iMtmData2 & KMmsMessageRoutedToApplication is ETrue and

            // if notification is NOT succesfully routed to app 

            // aContext.iError is KMmsErrorUnregisteredApplication.

            if(    ( aContext.iError == KMmsErrorUnregisteredApplication ) // To unregistered application

                || ( aContext.iMtmData2 & KMmsMessageRoutedToApplication ) )

                {

                LOGTEXT( _L8( "NotMtmUiData - Operation Retrieve not supported" ) );

                return R_EIK_TBUF_NOT_AVAILABLE;

                }

            if( msgstatus == EMsgStatusDeleted )

                { // Msg already been deleted from server

                LOGTEXT( _L8( "NotMtmUiData - Operation Retrieve not supported" ) );

                return R_EIK_TBUF_NOT_AVAILABLE;

                }

            if( msgstatus == EMsgStatusReadyForFetching 

                || msgstatus == EMsgStatusFailed )

                {   // Fetch is supported if the msg is waiting or something has been failed

                LOGTEXT( _L8( "NotMtmUiData - Operation Retrieve message supported" ) );

                return 0;

                }

            if (    msgstatus == EMsgStatusForwarded 

                &&  aContext.iMtmData2 & KMmsStoredInMMBox )

                { // Fetch is supported if it's forwarded and multiple forward is supported

                LOGTEXT( _L8( "NotMtmUiData - Operation Retrieve supported" ) );

                return 0;

                }

            // Otherwise it's not supported

            LOGTEXT( _L8( "NotMtmUiData - Operation Retrieve not supported" ) );

            return R_EIK_TBUF_NOT_AVAILABLE;

            }

        if (    ( aFunctionId == KMtmUiFunctionDeleteMessage )

            &&  ( aContext.iType == KUidMsvMessageEntry )

            &&  ( aContext.iMtmData2 & KMmsNewOperationForbidden ) ) // New Forbidden

                {

                LOGTEXT( _L8( "NotMtmUiData - Operation Delete not supported" ) );

                return R_EIK_TBUF_NOT_AVAILABLE;

                }

        if ( ( aFunctionId == KMtmUiFunctionDeleteMessage ) &&

            ( aContext.iType == KUidMsvMessageEntry ) &&

            ( msgstatus != EMsgStatusRetrieving ) &&

            ( msgstatus != EMsgStatusForwarding ) )

            {   // Delete is supported if msg is not retrieving or forwarding

            LOGTEXT( _L8( "NotMtmUiData - Operation Delete message supported" ) );

            return 0;

            }

        if ( ( aFunctionId == KMtmUiFunctionOpenMessage ) &&

            ( aContext.iType == KUidMsvMessageEntry ) &&

            ( aContext.iMtmData2 & KMmsNewOperationForbidden ) &&

            ( aContext.iMtmData2 & KMmsOperationForward  ) &&

            ( !( aContext.iMtmData2 & KMmsOperationFetch ) ) )

            {   // Open is supported only if forward is in progress

            LOGTEXT( _L8( "NotMtmUiData - Operation Open message supported" ) );

            return 0;

            }

        if ( ( aFunctionId == KMtmUiFunctionOpenMessage ) &&

            ( aContext.iType == KUidMsvMessageEntry ) &&

            ( msgstatus != EMsgStatusRetrieving ) &&

            ( msgstatus != EMsgStatusWaiting ) )

            {   // Open is supported if msg is not retrieving or forwarding

            LOGTEXT( _L8( "NotMtmUiData - Operation Open message supported" ) );

            return 0;

            }

        if ( ( aFunctionId == KMtmUiFunctionMoveTo ) &&

            ( aContext.iType == KUidMsvMessageEntry ) )

            {   // Move is never supported

            LOGTEXT( _L8( "NotMtmUiData - Operation MoveTo not supported" ) );

            return R_EIK_TBUF_NOT_AVAILABLE;

            }

        if ( ( aFunctionId == KMtmUiFunctionForward ) &&

            ( aContext.iType == KUidMsvMessageEntry ) )

            {

            if( aContext.iMtmData2 & KMmsNewOperationForbidden ) // New Forbidden

                {

                LOGTEXT( _L8( "NotMtmUiData - Operation Forward not supported" ) );

                return R_EIK_TBUF_NOT_AVAILABLE;

                }

            if( iNotUiDataFlags & EForwardSupported )

                {

                if( msgstatus == EMsgStatusDeleted )

                    {   // Forward not supported if msg has been deleted

                    LOGTEXT( _L8( "NotMtmUiData - Operation Retrieve not supported" ) );

                    return R_EIK_TBUF_NOT_AVAILABLE;

                    }

                // If notification is succesfully routed to app 

                // aContext.iMtmData2 & KMmsMessageRoutedToApplication is ETrue and

                // if notification is NOT succesfully routed to app 

                // aContext.iError is KMmsErrorUnregisteredApplication.

                if(    ( aContext.iError == KMmsErrorUnregisteredApplication ) // To unregistered application

                    || ( aContext.iMtmData2 & KMmsMessageRoutedToApplication ) )

                    {

                    LOGTEXT( _L8( "NotMtmUiData - Operation Forward not supported" ) );

                    return R_EIK_TBUF_NOT_AVAILABLE;

                    }

                if ( msgstatus == EMsgStatusReadyForFetching

                    || msgstatus == EMsgStatusFailed )

                    { // Forward supported if it's ready or failed

                    LOGTEXT( _L8( "NotMtmUiData - Operation Forward supported" ) );

                    return 0;

                    }

                if (    msgstatus == EMsgStatusForwarded

                    &&  aContext.iMtmData2 & KMmsStoredInMMBox )

                    { // Forward supported if it's forwarded and multiple forward supported

                    LOGTEXT( _L8( "NotMtmUiData - Operation Forward supported" ) );

                    return 0;

                    }

                // Otherwise forward is not supported

                LOGTEXT( _L8( "NotMtmUiData - Operation Forward not supported" ) );

                return R_EIK_TBUF_NOT_AVAILABLE;

                }

            else

                {   // If forward is not supported at all -> it's not supported

                LOGTEXT( _L8( "NotMtmUiData - Operation Forward not supported" ) );

                return R_EIK_TBUF_NOT_AVAILABLE;

                }

            }

        }

    else if( ( aContext.iMtmData1 & KMmsMessageTypeMask ) == KMmsMessageForwardReq ) // Forward request

        {

        // Only Message Info for messages is a supported operation

        if ( ( aFunctionId == KMtmUiFunctionMessageInfo ) &&

            ( aContext.iType == KUidMsvMessageEntry ) )

            { // Info always supported

            LOGTEXT( _L8( "NotMtmUiData - Operation Message Info supported" ) );

            return 0;

            }

        if ( ( aFunctionId == KMtmUiFunctionDeferSending ) &&

            ( aContext.iType == KUidMsvMessageEntry ) )

            { // Defer never supported

            LOGTEXT( _L8( "NotMtmUiData - Operation Defer sending not supported" ) );

            return R_EIK_TBUF_NOT_AVAILABLE;

            }

        if ( ( aFunctionId == KMtmUiFunctionMoveTo ) &&

            ( aContext.iType == KUidMsvMessageEntry ) )

            { // MoveTo never supported

            LOGTEXT( _L8( "NotMtmUiData - Operation MoveTo not supported" ) );

            return R_EIK_TBUF_NOT_AVAILABLE;

            }

        if ( ( aFunctionId == KMtmUiFunctionDeleteMessage ) &&

            ( aContext.iType == KUidMsvMessageEntry ) )

            { // Delete supported

            LOGTEXT( _L8( "NotMtmUiData - Operation Delete supported" ) );

            return 0;

            }

        if ( ( aFunctionId == KMtmUiFunctionOpenMessage ) &&

            ( aContext.iType == KUidMsvMessageEntry ) &&

            ( aContext.Parent( ) == KMsvSentEntryId ) )

            { // Open supported in Sent items only

            LOGTEXT( _L8( "NotMtmUiData - Operation Open supported in Sent" ) );

            return 0;

            }

        if ( ( aFunctionId == KMtmUiFunctionSend ) &&

            ( aContext.iType == KUidMsvMessageEntry ) )

            { // Send is supported

            LOGTEXT( _L8( "NotMtmUiData - Operation Send supported" ) );

            return 0;

            } 

        }

    if ( ( aFunctionId == KMtmUiFunctionDeleteMessage ) &&

        ( aContext.iType == KUidMsvMessageEntry ) &&

        ! ( aContext.iMtmData2 & KMmsNewOperationForbidden ) ) 

        {

        LOGTEXT( _L8( "NotMtmUiData - Operation Delete is supported as message type is treated as Unknown" ) );

        return 0;

        }

    LOGTEXT( _L8( "NotMtmUiData - Operation not supported" ) );

    return R_EIK_TBUF_NOT_AVAILABLE;

    }

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

// CNotMtmUiData::QueryCapability

// The default UI capability checker (UI MTM may have also minimal

// UI specific checks also)

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

//

TInt CNotMtmUiData::QueryCapability(

    TUid aFunctionId,

    TInt& aResponse ) const

    {

    TInt error = KErrNone;

    switch ( aFunctionId.iUid )

        {

        // Supported:

        case KUidMtmQueryMaxTotalMsgSizeValue:

            aResponse = KMaxTInt;

            break;

        case KUidMsvMtmQueryEditorUidValue:

            aResponse = KNotViewer;

            break;

        case KUidMsvMtmQueryViewerUidValue:

            aResponse = KNotViewer;

            break;

        case KUidMsvMtmQuerySupportLinks: // flow through

        case KUidMsvMtmUiQueryMessagingInitialisation: // flow through. This is also in UI MTM!

        case KUidMsvMtmQueryFactorySettings: // This is also in UI MTM!

            aResponse = ETrue;

            break;

        case KUidMtmQuerySupportAttachmentsValue:

        case KUidMtmQueryCanReceiveMsgValue:

        case KUidMsvMtmQueryMessageInfo:

            break;

        default:

            // All others - Not Supported. At least these:

            //KUidMtmQueryCanCreateNewMsgValue

            //KUidMtmQueryCanSendMsgValue

            //KUidMtmQuerySupportedBodyValue: text part(s) are attachments!

            //KUidMtmQueryMaxBodySizeValue: texts part(s) are attachments!

            //KUidMtmQuerySupportSubjectValue: subject is supported in Viewer, but not in Editor

            //KUidMsvMtmUiQueryCanPrintPreviewMsgValue: no printing in Series 60

            //KUidMsvMtmUiQueryCanPrintMsgValue: no printing in Series 60

            //KUidMtmQueryMaxRecipientCountValue

            //KUidMtmQuerySupportsBioMsgValue

            //KUidMtmQuerySendAsRequiresRenderedImageValue

            //KUidMtmQuerySendAsRenderingUidValue

            //KUidMsvMtmUiQueryExtendedOpenProgress

            //KUidMsvMtmUiQueryExtendedGetMailProgress

            //KUidMsvMtmUiQueryConnectionOrientedServices

            //KUidMsvMtmUiQueryServiceAttributes

            //KUidMsvMtmUiQueryCanGetNew

            //KUidMsvMtmUiQueryCanOpenServiceOnAction

            //KUidMtmQueryOffLineAllowedValue

            //KUidMtmQuerySupportsSchedulingValue

            //KUidMtmQuerySupportsFolderValue

            error = KErrNotSupported;

        }

    LOGTEXT2( _L16( "NotMtmUiData - QueryCapability: %d" ), error );

    return error;   

    }

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

// CNotMtmUiData::ContextIcon

// Returns the array of icons relevant to given entry

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

//

const CNotMtmUiData::CBitmapArray& CNotMtmUiData::ContextIcon(

    const TMsvEntry& aContext,

    TInt /*aStateFlags*/ ) const

    {

    //    Return the set of icons (i.e. different sizes) appropriate to the current context

    __ASSERT_DEBUG( aContext.iMtm == KUidMsgMMSNotification, Panic( EMmsWrongMtm ) );

    __ASSERT_DEBUG( aContext.iType.iUid != KUidMsvFolderEntryValue, Panic( EMmsFoldersNotSupported ) );

    __ASSERT_DEBUG( aContext.iType.iUid != KUidMsvAttachmentEntryValue, Panic( EMmsNoIconForAttachment ) );

    const TInt bmpIndex = aContext.Unread() ? KMmsUnreadIconIndex : KMmsReadIconIndex;

    return *iIconArrays->At( bmpIndex );

    }

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

// CNotMtmUiData::CanCreateEntryL

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

//

TBool CNotMtmUiData::CanCreateEntryL(

    const TMsvEntry& /*aParent*/,

    TMsvEntry& /*aNewEntry*/,

    TInt& aReasonResourceId ) const

    {

    aReasonResourceId = R_EIK_TBUF_NOT_AVAILABLE;

    return EFalse;

    }

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

// CNotMtmUiData::CanOpenEntryL

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

//

TBool CNotMtmUiData::CanOpenEntryL(

    const TMsvEntry& /*aContext*/,

    TInt& aReasonResourceId ) const

    {

    aReasonResourceId = R_EIK_TBUF_NOT_AVAILABLE;

    return EFalse;

    }

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

// CNotMtmUiData::CanCloseEntryL

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

//

TBool CNotMtmUiData::CanCloseEntryL(

    const TMsvEntry& /*aContext*/,

    TInt& aReasonResourceId ) const

    {

    aReasonResourceId=R_EIK_TBUF_NOT_AVAILABLE;

    return EFalse;

    }

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

// CNotMtmUiData::CanViewEntryL

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

//

TBool CNotMtmUiData::CanViewEntryL(

    const TMsvEntry& /*aContext*/,

    TInt& aReasonResourceId ) const

    {

    aReasonResourceId = R_EIK_TBUF_NOT_AVAILABLE;

    return EFalse;

    }

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

// CNotMtmUiData::CanEditEntryL

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

//

TBool CNotMtmUiData::CanEditEntryL(

    const TMsvEntry& /*aContext*/,

    TInt& aReasonResourceId ) const

    {

    aReasonResourceId = R_EIK_TBUF_NOT_AVAILABLE;

    return EFalse;

    }

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

// CNotMtmUiData::CanDeleteFromEntryL

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

//

TBool CNotMtmUiData::CanDeleteFromEntryL(

    const TMsvEntry& /*aContext*/,

    TInt& aReasonResourceId ) const

    {

    aReasonResourceId = R_EIK_TBUF_NOT_AVAILABLE;