/*

* Copyright (c) 2005-2008 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:  Class for new message shortcut target

*

*/

#include <sendui.h>         // For CSendUi

#include <sendnorm.rsg>     // For settings not ok - error dialog

#include <gulicon.h>        // For CGulIcon

#include <SenduiMtmUids.h>

#include <cemailaccounts.h> // For finding out available email account counts

#include <AknsUtils.h>      // For AknsUtils

#include <avkon.rsg>

#include <data_caging_path_literals.hrh>

#include <AknGlobalNote.h>  // For error note

#include <MuiuMsvUiServiceUtilities.h>

#include <StringLoader.h>

#include "aiscutcontentmodel.h"

#include "caiscuttargetnewmsg.h"

#include "caiscutengine.h"

#include <aiscutplugin.mbg>

#include <e32property.h>

#include <connect/sbdefs.h>

#include <filemanagerbkupchecker.rsg>

#include <aiscuttexts.rsg>

#include "debug.h"

using namespace conn;

const TInt KMaxBufSize = 256;

// Status keys adopted from FileManager to be used when checking file backup status

const TUid KPSUidFileManagerStatus = { 0x101F84EB }; // File Manager SID

const TUint32 KFileManagerBkupStatus = 0x00000001;

enum TFileManagerBkupStatusType

    {

    EFileManagerBkupStatusUnset   = 0x00000000,

    EFileManagerBkupStatusBackup  = 0x00000001,

    EFileManagerBkupStatusRestore = 0x00000002

    };

TBool PhoneIsInBackupOrRestoreMode()

    {

    TBool backupOrRestore = EFalse;

    TInt status( EFileManagerBkupStatusUnset );

    TInt err( RProperty::Get( KPSUidFileManagerStatus, KFileManagerBkupStatus, status ) );

    if ( status == EFileManagerBkupStatusBackup )

    {

    	backupOrRestore = ETrue;

    	return backupOrRestore;

    }

    // Get the back-up restore key, return EFalse if we can't get the key

    TInt keyVal = 0;

    const TInt error = RProperty::Get( KUidSystemCategory, conn::KUidBackupRestoreKey, keyVal );

    if( error )

        {

        return backupOrRestore;

        }

    const conn::TBURPartType partType = static_cast< conn::TBURPartType >( keyVal & conn::KBURPartTypeMask );

    if  (keyVal != 0)

        {

        switch(partType)

            {

        case EBURUnset:

        case EBURNormal:

            break;

        case EBURBackupFull:

        case EBURBackupPartial:

        case EBURRestoreFull:

        case EBURRestorePartial:

            backupOrRestore = ETrue;

            break;

            }

        }

    //

    return backupOrRestore;

    }

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

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

//

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

//

CAiScutTargetNewMsg::CAiScutTargetNewMsg(CAiScutEngine& aEngine, TShortcutType aType)

    : CAiScutTarget(aEngine, aType)

{

}

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

//

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

//

void CAiScutTargetNewMsg::ConstructL(const TAiScutParser& aParser)

{

    iDefinition = aParser.Get(EScutDefComplete).AllocL();

    iAppUid       = KNullUid;

    iViewUid.iUid = -1;

    switch (aParser.Type())

    {

    case EScutNewMessage:

        iMtm          = KSenduiMtmUniMessageUid;

        iAppUid.iUid  = KScutUnifiedEditorUidValue;

        break;

    case EScutNewEmail:

        iMtm          = KSenduiMtmSmtpUid;

        iAppUid.iUid  = KScutEmailEditorUidValue;

        break;

#ifdef __SYNCML_DS_EMAIL

    case EScutNewSyncMLMail:

        iMtm          = KSenduiMtmSyncMLEmailUid;

        iAppUid.iUid  = KScutEmailEditorUidValue; // check that these uids are in sync with aiscuttexts.rss

        iViewUid.iUid = KScutSyncMlEmailUidValue;

        break;

#endif

    case EScutNewPostcard:

        iMtm          = KSenduiMtmPostcardUid;

        iAppUid.iUid  = KScutPostcardEditorUidValue;

        break;

    case EScutNewAudioMsg:

        iMtm          = KSenduiMtmAudioMessageUid;

        iAppUid.iUid  = KScutAmsEditorUidValue;

        break;

    case EScutNewMsgType:

        iAppUid.iUid  = KScutMessagingCenterUidValue; // check that these uids are in sync with aiscuttexts.rss

        iViewUid.iUid = KScutMessagingCenterUidValue;

        // fallthrough

    default:

        iMtm = KNullUid;

        break;

    }

}

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

//

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

//

CAiScutTargetNewMsg* CAiScutTargetNewMsg::NewL(

    CAiScutEngine& aEngine, TShortcutType aType, const TAiScutParser& aParser)

{

    CAiScutTargetNewMsg* self = new (ELeave) CAiScutTargetNewMsg(aEngine, aType);

    CleanupStack::PushL(self);

    self->ConstructL(aParser);

    CleanupStack::Pop(self);

    return self;

}

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

//

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

//

CAiScutTargetNewMsg::~CAiScutTargetNewMsg()

{

    delete iCaption;

    delete iShortCaption;

    delete iDefinition;

}

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

// Returns the shortcut definition string.

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

//

TPtrC CAiScutTargetNewMsg::Definition() const

{

    return TPtrC(*iDefinition);

}

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

// Returns the shortcut target caption.

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

//

TInt CAiScutTargetNewMsg::GetCaption(TPtrC& aDes, TAiScutAppTitleType aTitleType) const

{

    TRAP_IGNORE(GetCaptionL(aTitleType));

    if (aTitleType == EAiScutSkeyTitle)

    {

        aDes.Set(iShortCaption ? *iShortCaption : KNullDesC());

    }

    else

    {

        aDes.Set(iCaption ? *iCaption : KNullDesC());

    }

    return 0;

}

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

// Returns the shortcut target caption.

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

//

void CAiScutTargetNewMsg::GetCaptionL(TAiScutAppTitleType aTitleType) const

{

    HBufC* titlePtr = HBufC::NewLC(KMaxBufSize);

    TPtr titlePtrP = titlePtr->Des();

    // Use lazy evaluation, create the caption only when it is first needed.

    if (aTitleType == EAiScutSkeyTitle)

    {

        if (!iShortCaption)

        {

            if (iEngine.GetAppTitle(iAppUid, iViewUid, titlePtrP, aTitleType))

            {

                iShortCaption = titlePtrP.AllocL();

            }

        }

    }

    else

    {

        if (!iCaption)

        {

            if (iEngine.GetAppTitle(iAppUid, iViewUid, titlePtrP, aTitleType))

            {

                iCaption = titlePtrP.AllocL();

            }

        }

    }

    CleanupStack::PopAndDestroy(titlePtr);

}

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

// Returns the shortcut target icon.

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

//

TInt CAiScutTargetNewMsg::GetIcon(CGulIcon*& aIcon) const

{

    if ( CAiScutTarget::GetIcon(aIcon) != KErrNone )

        {

        TRAP_IGNORE(GetIconL(aIcon));

        }

    return 0;

}

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

// Returns the shortcut target icon.

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

//

void CAiScutTargetNewMsg::GetIconL(CGulIcon*& aIcon) const

{

    CGulIcon* tempIcon = NULL;

    TBool useAppIcon = ETrue;

    TInt iconId = 0;

    TInt maskId = 0;

    if (iMtm == KNullUid)

    {

        useAppIcon = EFalse;

        iconId = EMbmAiscutpluginQgn_menu_mce_sel_mes;

        maskId = EMbmAiscutpluginQgn_menu_mce_sel_mes_mask;

    }

#ifdef __SYNCML_DS_EMAIL

    else if (iMtm.iUid == KSenduiMtmSyncMLEmailUidValue)

    {

        useAppIcon = EFalse;

        iconId = EMbmAiscutpluginQgn_menu_mce_syncmail;

        maskId = EMbmAiscutpluginQgn_menu_mce_syncmail_mask;

    }

#endif

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    if (useAppIcon)

    {

        CFbsBitmap* bitmap = NULL;

        CFbsBitmap* mask   = NULL;

        AknsUtils::CreateAppIconLC(skin, iAppUid, EAknsAppIconTypeList, bitmap, mask);

        tempIcon = CGulIcon::NewL(bitmap, mask);

        CleanupStack::Pop(2); // Bitmap and mask. They have to be popped out by number

                              // because the order in which they are pushed in is undefined.

    }

    else

    {

        TFileName pluginIconFile(KDC_APP_BITMAP_DIR);

        pluginIconFile.Append(KBitmapFile);

        tempIcon = AknsUtils::CreateGulIconL(

            skin,

            KAknsIIDQgnPropAiShortcut,

            pluginIconFile,

            iconId,

            maskId

            );

    }

    //Do not need to sets the bitmap and mask to be owned externally

    aIcon = tempIcon;

}

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

// Checks if the shortcut target is accessible.

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

//

TBool CAiScutTargetNewMsg::IsAccessibleL(TInt /*aCheckType*/)

{

    return ETrue;

}

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

// Launches the message editor to send an Sms, Mms or Email message.

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

//

void CAiScutTargetNewMsg::LaunchL()

    {

    if( PhoneIsInBackupOrRestoreMode() )

        {

        CAknGlobalNote* note = CAknGlobalNote::NewLC();

        HBufC* prompt = StringLoader::LoadLC( R_QTN_AI_SCUT_OPERATION_DISABLED );

        note->SetSoftkeys( R_AVKON_SOFTKEYS_OK_EMPTY );

        note->ShowNoteL( EAknGlobalInformationNote, *prompt );

        CleanupStack::PopAndDestroy( prompt );

        CleanupStack::PopAndDestroy( note );

        return;

        }

  CSendUi* sendUi = CSendUi::NewLC();

    if (iMtm == KNullUid)

        {

        TSendingCapabilities capabs(0, 0, TSendingCapabilities::ESupportsEditor);

        TUid uid = sendUi->ShowTypedQueryL(CSendUi::EWriteMenu, NULL, capabs, NULL, KNullDesC);

        if (uid != KNullUid)

            {

            sendUi->ServiceCapabilitiesL(uid, capabs);

            sendUi->CreateAndSendMessageL(uid, NULL, KNullUid, EFalse); // launch standalone

            }

        }

    else

        {

        if( iMtm == KSenduiMtmSmtpUid ) // pop, imap, smtp

            {

            RArray<TPopAccount> popAccounts;

            RArray<TImapAccount> imapAccounts;

            RArray<TSmtpAccount> smtpAccounts;

            CEmailAccounts* emailAccounts = CEmailAccounts::NewLC();

            // check that mailbox exists or else display error message

            emailAccounts->GetPopAccountsL(popAccounts);

            emailAccounts->GetImapAccountsL(imapAccounts);

            emailAccounts->GetSmtpAccountsL(smtpAccounts);

            CleanupStack::PopAndDestroy(emailAccounts);

            if( iMtm == KSenduiMtmSmtpUid &&

                (popAccounts.Count() + imapAccounts.Count() + smtpAccounts.Count() ) > 0 )

                {

                sendUi->CreateAndSendMessageL(iMtm, NULL, KNullUid, EFalse); // launch standalone

                }

            else

                {

                ShowErrorNote();

                }

            popAccounts.Reset();

            imapAccounts.Reset();

            smtpAccounts.Reset();

            }

        else if ( iMtm == KSenduiMtmSyncMLEmailUid ) // syncml

            {

            CMsvEntrySelection* sel =

                MsvUiServiceUtilities::GetListOfAccountsWithMTML( *(iEngine.MsvSession()), iMtm );

            TInt accounts = sel->Count();

            delete sel;

            if ( accounts > 0 )

                {

                sendUi->CreateAndSendMessageL(iMtm, NULL, KNullUid, EFalse); // launch standalone

                }

            else

                {

                ShowErrorNote();

                }

            }

        else

            {

            sendUi->CreateAndSendMessageL(iMtm, NULL, KNullUid, EFalse); // launch standalone

            }

    }

    CleanupStack::PopAndDestroy(sendUi);

}

void CAiScutTargetNewMsg::ShowErrorNote()

    {

     TRAP_IGNORE(

        // Display global error note.

        CAknGlobalNote* note = CAknGlobalNote::NewLC();

        HBufC* prompt = StringLoader::LoadLC( R_SENDUI_SETTINGS_NOT_OK );

        note->ShowNoteL( EAknGlobalErrorNote, *prompt );

        CleanupStack::PopAndDestroy( prompt );

        CleanupStack::PopAndDestroy( note );

    ); // end TRAP_IGNORE

    }

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

// Return application uid this target launches.

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

//

TUid CAiScutTargetNewMsg::AppUid() const

{

    return iAppUid;

}

// End of File.