/*

 * Copyright (c) 2002-2010 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:    LandmarksUi Sender class implementation

 *

 */

// INCLUDE FILES

#include <e32std.h>

#include <StringLoader.h>

#include <f32file.h>

#include <AknWaitDialog.h>

#include <coemain.h>

#include <eikmenup.h>

#include <AknQueryDialog.h>

#include <sendui.h>

#include <SenduiMtmUids.h>

#include <CMessageData.h>

#include <EPos_CPosLandmarkDatabase.h>

#include <EPos_CPosLandmark.h>

#include <EPos_CPosLmCategoryManager.h>

#include <lmkui.rsg>

#include "LmkConsts.h"

#include "CLmkEncoder.h"

#include "landmarks.hrh"

#include "CLmkUiUtils.h"

#include "LmkFileUtils.h"

#include "Debug.h"

#include "CLmkSender.h"

#include "CLmkFields.h"

#include "LmkConsts.h"

#include "CLmkDbUtils.h"

#include <CSendingServiceInfo.h>

#include <lmkerrors.h>

// CONSTANTS

//for the sendui query

const static TInt KBluetooth = 0x10009ed5;

const static TInt KInfrared = 0x100053A4;

const static TInt KEmail = 0x10001028;

const static TInt KMessaging = 0x102072D6;

const TInt KNumOfReplaceChars(25);

/// Unnamed namespace for local definitions

namespace

    {

    const TInt KLmkMtmFilterGranularity(8);

#if defined(_DEBUG)

    _LIT( KPanicMsg, "CLmkSender" );

    void Panic(TPanicCode aReason)

        {

        User::Panic(KPanicMsg, aReason);

        }

#endif

    } // namespace

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

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

// CLmkSender::CLmkSender

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

// might leave.

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

//

CLmkSender::CLmkSender(CPosLandmarkDatabase& aDb) :

    iLastOperationResult(KErrNone), iDb(aDb)

    {

    }

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

// CLmkSender::ConstructL

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

//

void CLmkSender::ConstructL(CPosLandmarkDatabase& aDb)

    {

    iSendUi = CSendUi::NewL();

    iEncoder = CLmkEncoder::NewL(aDb, *this, ETrue);

    }

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

// CLmkSender::NewL

// Two-phased constructor.

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

//

EXPORT_C CLmkSender* CLmkSender::NewL(CPosLandmarkDatabase& aDb)

    {

    CLmkSender* self = new (ELeave) CLmkSender(aDb);

    CleanupStack::PushL(self);

    self->ConstructL(aDb);

    CleanupStack::Pop();

    return self;

    }

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

// CLmkSender::~CLmkSender

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

//

CLmkSender::~CLmkSender()

    {

    if (iWaitNote)

        {

        TRAPD( err, iWaitNote->ProcessFinishedL() );

        if (err != KErrNone)

            {

            delete iWaitNote;

            iWaitNote = NULL;

            }

        }

    delete iEncoder;

    delete iSendUi;

    }

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

// CLmkSender::DisplaySendMenuL

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

//

EXPORT_C void CLmkSender::DisplaySendMenuL(CEikMenuPane& aMenuPane,

        TInt aVisibleCount, TInt aMenuTextResource) const

    {

    TInt pos(0);

    aMenuPane.ItemAndPos(ELmkCmdSendDummy, pos);

    // Set dummy command dimmed anyway. It was only needed because

    // SendUI needs to know the right position:

    aMenuPane.SetItemDimmed(ELmkCmdSendDummy, ETrue);

    // Now if there are items visible then let SendUi check whether

    // option can be shown:

    if (aVisibleCount > 0)

        {

        TSendingCapabilities capabilities(0, 0,

                TSendingCapabilities::EAllServices);

        iSendUi->AddSendMenuItemL(aMenuPane, pos, ELmkCmdSend, capabilities);

        // Set menu item text to desired value since previous operation

        // overrides it with SendUI default value.

        if (aMenuTextResource != KZeroResourceId)

            {

            aMenuPane.SetItemTextL(ELmkCmdSend, aMenuTextResource);

            }

        }

    }

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

// CLmkSender::DisplaySendCascadeMenuL

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

//

EXPORT_C void CLmkSender::DisplaySendCascadeMenuL(CEikMenuPane& /*aMenuPane*/) const

    {

    // Construct the MTM filter

    CArrayFixFlat<TUid>* mtmFilter = new (ELeave) CArrayFixFlat<TUid> (

            KLmkMtmFilterGranularity);

    CleanupStack::PushL(mtmFilter);

    mtmFilter->AppendL(KSenduiMtmSmsUid); // hide SMS

    mtmFilter->AppendL(KSenduiMtmFaxUid); // hide fax

    CleanupStack::PopAndDestroy(); // mtmFilter

    }

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

// CLmkSender::CreateAndSendL

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

//

void CLmkSender::CreateAndSendL(TInt aCommandId,

        const RArray<TPosLmItemId>& aMarkedIds, TPosLmItemId aSelectedId)

    {

    DEBUG( CLmkSender::CreateAndSendL entered );

    HBufC* filePath;

    PrepareSendFilePathL(filePath);

    TPtr ptr = filePath->Des();

    TInt markedCount = aMarkedIds.Count();

    if (markedCount == 0 || markedCount == 1)

        {

        // One item only marked or unmarked

        RArray<TPosLmItemId> lmIdArray(1);

        CleanupClosePushL(lmIdArray);

        User::LeaveIfError(lmIdArray.Append(aSelectedId));

        CPosLandmark* landmark = iDb.ReadLandmarkLC(aSelectedId);

        HBufC* webUrl = HBufC::NewL(KMaxBufferLen);

        CleanupStack::PushL(webUrl);

        TPtrC urlDes = webUrl->Des();

        landmark->GetPositionField(ELmkPositionFieldWebAddress, urlDes);

        if (urlDes.Length() > KMaxUrlFieldLenWithDefaultProtocol)

            {

            TInt pos = urlDes.Find(KProtocol);

            if (pos == KErrNotFound)

                {

                webUrl = webUrl->ReAllocL(KHttp().Length() + urlDes.Length());

                TPtr url = webUrl->Des();

                webUrl->Des().Copy(urlDes);

                webUrl->Des().Insert(0, KHttp);

                landmark->SetPositionFieldL(ELmkPositionFieldWebAddress,

                        webUrl->Des());

                }

            }

        CleanupStack::PopAndDestroy();//webUrl

        TPtrC landmarkName;

        TInt retVal(0);

        retVal = landmark->GetLandmarkName(landmarkName);

        if (retVal == KErrNone)

            {

            iEncoder->StartEncodingL(landmarkName, lmIdArray);

            ptr.Append(landmarkName);

            }

        else

            {

            iEncoder->StartEncodingL(KLmkEncodedDataFileName, lmIdArray);

            ptr.Append(KLmkEncodedDataFileName);

            }

        SendL(ptr, aCommandId);

        CleanupStack::PopAndDestroy(2); //landmark, lmIdArray

        }

    else

        {

        HBufC* pckgName;

        TPtrC currentPckgName;//not really used, only for passing to the func.

        if (QueryNewPackageNameLC(currentPckgName, pckgName))

            {

            TPtr name = pckgName->Des();

            iEncoder->StartEncodingL(name, aMarkedIds);

            ptr.Append(name);

            SendL(ptr, aCommandId);

            }

        CleanupStack::PopAndDestroy();

        }

    CleanupStack::PopAndDestroy(filePath); //filePath       

    }

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

// CLmkSender::HandleOperationL

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

//

void CLmkSender::HandleOperationL(TOperationTypes /*aType*/,

        TReal32 /*aProgress*/, TInt aStatus)

    {

    if (aStatus != KPosLmOperationNotComplete)

        {

        __ASSERT_DEBUG( iWaitNote, Panic( KLmkPanicNullMember ) );

        iWaitNote->ProcessFinishedL();

        iWaitNote = NULL;

        iLastOperationResult = aStatus;

        }

    }

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

// CLmkSender::SendLandmarksL

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

//

void CLmkSender::SendLandmarksL(TInt aCommandId, const TDesC& aPackageName,

        const RPointerArray<CLmkLandmark>& aLandmarks)

    {

    DEBUG( CLmkSender::SendMultipleLandmarkL entered );

    TInt lmkCount = aLandmarks.Count();

    __ASSERT_DEBUG(lmkCount > 0, Panic( KLmkPanicNullMember ) );

    if (lmkCount == 1)

        {

        SendSingleLandmarkL(aCommandId, aLandmarks);

        }

    else

        {

        SendLandmarksPackageL(aCommandId, aPackageName, aLandmarks);

        }

    }

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

// CLmkSender::SendSingleLandmarkL

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

//

void CLmkSender::SendSingleLandmarkL(const CPosLandmark& alandmark)

    {

    CLmkLandmark* lmkLandmark;

    LmkLandmarkFromPosLandmarkL(lmkLandmark, alandmark);

    SendSingleLandmarkL(ELmkCmdSend, *lmkLandmark);

    CleanupStack::PopAndDestroy();//landMarkLmk

    }

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

// CLmkSender::SendSingleLandmarkL()

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

//

void CLmkSender::SendSingleLandmarkL(TInt aCommandId,

        const CLmkLandmark& alandmark)

    {

    TPtrC ptr;

    RPointerArray<CLmkLandmark> landmark;

    landmark.Append(&alandmark);

    SendLandmarksL(aCommandId, ptr, landmark);

    landmark.Close();

    }

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

// CLmkSender::SendSingleLandmarkL()

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

//

void CLmkSender::SendSingleLandmarkL(TInt aCommandId, const RPointerArray<

        CLmkLandmark>& aLandmarks)

    {

    HBufC* filePath;

    PrepareSendFilePathL(filePath);

    TPtr ptr = filePath->Des();

    CLmkLandmark* lmk = aLandmarks[0];

    CPosLandmark* landmark = lmk->PosLandmark();

    CLmkDbUtils::AddDefaultProtocolL(landmark);

    TPtrC landmarkName;

    TInt retVal(KErrNone);

    retVal = landmark->GetLandmarkName(landmarkName);

    if (retVal == KErrNone && LmkFileUtils::IsValidPathL(landmarkName))

        {

        TRAP(retVal,iEncoder->StartEncodingL(landmarkName,aLandmarks));

        if (retVal == KErrNone)

            {

            ptr.Append(landmarkName);

            }

        }

    else

        {

        retVal = KErrBadName;

        }

    if (retVal != KErrNone)

        {

        TPtr lmName = ReplaceSpecialCharactersL(landmarkName);

        TRAP(retVal,iEncoder->StartEncodingL(lmName,aLandmarks));

        if (retVal == KErrNone)

            {

            ptr.Append(lmName);

            }

        else

            {

            iEncoder->StartEncodingL(KLmkEncodedDataFileName, aLandmarks);

            ptr.Append(KLmkEncodedDataFileName);

            }

        }

    SendL(ptr, aCommandId);

    CleanupStack::PopAndDestroy(filePath); //filePath

    }

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

// CLmkSender::SendLandmarksPackageL

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

//

void CLmkSender::SendLandmarksPackageL(TInt aCommandId,

        const TDesC& aPackageName,

        const RPointerArray<CLmkLandmark>& aLandmarks)

    {

    HBufC* pckgName;

    HBufC* filePath;

    PrepareSendFilePathL(filePath);

    TPtr ptr = filePath->Des();

    if (QueryNewPackageNameLC(aPackageName, pckgName))

        {

        TPtr desName = pckgName->Des();

        iEncoder->StartEncodingL(desName, aLandmarks);

        ptr.Append(desName);

        SendL(ptr, aCommandId);

        }

    CleanupStack::PopAndDestroy(2);

    }

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

// CLmkSender::SendL()

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

//

void CLmkSender::SendL(TDes& aFilePath, TInt aCommandId)

    {

    aFilePath.Append(KLmkEncodedDataFileExtension);

    iWaitNote = new (ELeave) CAknWaitDialog(NULL, ETrue);

    if (iWaitNote->ExecuteLD(R_LMK_ENCODING_WAIT_NOTE))

        {

        if (iLastOperationResult == KErrNone)

            {

            RFs fs;

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

            CleanupClosePushL(fs);

            User::LeaveIfError(fs.ShareProtected());

            RFile fileHandle;

            User::LeaveIfError(fileHandle.Open(fs, aFilePath, EFileShareAny));

            CleanupClosePushL(fileHandle);

            TRAPD( err, SendFileL( aCommandId, fileHandle, ETrue));

            if (err != KErrNone)

                {

                CleanupStack::PopAndDestroy(); // fileHandle

                LmkFileUtils::DeleteFileL(aFilePath);

                CleanupStack::PopAndDestroy(); // fs

                User::LeaveIfError(err);

                }

            CleanupStack::PopAndDestroy(); // fileHandle

            LmkFileUtils::DeleteFileL(aFilePath);

            CleanupStack::PopAndDestroy(); // fs

            }

        else

            { // error situation

            CCoeEnv::Static()->HandleError(iLastOperationResult);

            }

        }

    else

        {

        //making iWaitNote null, since framework destroys waitnote

        //dialog on pressing cancel.

        iWaitNote = NULL;

        iEncoder->CancelEncodeOperationL();

        }

    }

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

// CLmkSender::SendFileL

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

//

void CLmkSender::SendFileL(TInt /*aCommandId*/, const TDesC& aFile,

        TBool aDeleteSentFile)

    {

    DEBUG( CLmkSender::SendFileL entered );

    // one attachment only:

    CMessageData * messageData = CMessageData::NewL();

    CleanupStack::PushL( messageData );

    messageData->AppendAttachmentL( aFile );

    DEBUG( CLmkSender::SendFileL: calling SendUI );

    LoadFilteredSendListQueryL(messageData);

    DEBUG( CLmkSender::SendFileL: SendUI returned );

    // Delete the file since it is no more needed

    if( aDeleteSentFile )

        {

        LmkFileUtils::DeleteFileL( aFile );

        }

    CleanupStack::PopAndDestroy( messageData );

    }

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

// CLmkSender::SendFileL -- FileHandle version

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

//

void CLmkSender::SendFileL(TInt /*aCommandId*/, RFile& aFile, TBool /*aDeleteSentFile*/)

    {

    DEBUG( CLmkSender::SendFileL entered );

    // one attachment only:

    CMessageData * messageData = CMessageData::NewL();

    CleanupStack::PushL(messageData);

    messageData->AppendAttachmentHandleL(aFile);

    DEBUG( CLmkSender::SendFileL: calling SendUI );

    LoadFilteredSendListQueryL(messageData);

    CleanupStack::PopAndDestroy(); //messageData

    DEBUG( CLmkSender::SendFileL: SendUI returned );

    }

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

// CLmkSender::QueryPackageName

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

//

TBool CLmkSender::QueryNewPackageNameLC(const TDesC& aCurrentPckgName,

        HBufC*& aNewPackageName)

    {

    TBool retVal = EFalse;

    HBufC* pkgName = StringLoader::LoadL(R_LMK_DEFAULT_PACKAGE_NAME,

            CEikonEnv::Static());

    if (aCurrentPckgName.Length() > pkgName->Des().Length())

        {

        delete pkgName;

        pkgName = NULL;

        pkgName = HBufC::NewL(aCurrentPckgName.Length());

        pkgName->Des().Copy(aCurrentPckgName);

        }

    TPtr desName = pkgName->Des();

    CAknTextQueryDialog* dlg = new (ELeave) CAknTextQueryDialog(desName,

            CAknQueryDialog::ENoTone);

    if (dlg->ExecuteLD(R_LMK_PACKAGE_NAME_QUERY))

        {

        retVal = ETrue;

        if (!LmkFileUtils::IsValidPathL(desName))

            {

            delete pkgName;

            pkgName = NULL;

            TInt len = KLmkEncodedDataFileName().Length();

            aNewPackageName = HBufC::NewLC(len);

            aNewPackageName->Des().Copy(KLmkEncodedDataFileName);

            return retVal;

            }

        }

    aNewPackageName = HBufC::NewLC(pkgName->Des().Length());

    aNewPackageName->Des().Copy(pkgName->Des());

    delete pkgName;

    pkgName = NULL;

    return retVal;

    }

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

// CLmkSender::LmkLandmarkFromPosLandmarkL()

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

//

void CLmkSender::LmkLandmarkFromPosLandmarkL(CLmkLandmark*& aLmkLandmark,

        const CPosLandmark& aPosLandmark)

    {

    RArray<TPosLmItemId> categoryIdArray;

    RPointerArray<CPosLandmarkCategory> categories;

    aPosLandmark.GetCategoriesL(categoryIdArray);

    CPosLmCategoryManager* categoryMgr = CPosLmCategoryManager::NewL(iDb);

    CleanupStack::PushL(categoryMgr);

    TInt catCount = categoryIdArray.Count();

    for (TInt i = 0; i < catCount; i++)

        {

        TPosLmItemId catId = categoryIdArray[i];

        CPosLandmarkCategory* category = categoryMgr->ReadCategoryLC(catId);

        categories.Append(category);

        CleanupStack::Pop();

        }

    categoryIdArray.Close();

    CleanupStack::PopAndDestroy();//categoryMgr