/*

* 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:  ESMR Location plugin handler implementation

*

*/

#include "emailtrace.h"

#include "cesmrlocationpluginhandler.h"

#include <calentry.h>

#include <esmrgui.rsg>

//<cmail>

#include "cesmrurlparserplugin.h"

//</cmail>

#include <ct/rcpointerarray.h>

#include "cesmrlocationplugin.h"

#include "esmrcommands.h"

#include "mesmrcalentry.h"

#include "cesmrdynamicitemselectionlist.h"

#include "cesmrlocationhistorymanager.h"

#include "mesmrlocationhistoryitem.h"

#include "cesmrconfirmationquery.h"

// Unnamed namespace for local definitions

namespace { //codescanner::namespace

_LIT(KSpace, " ");

// Maximum length of the text in location field

const TInt KMaxLocationTextLength = 255;

}

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

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

// CESMRLocationPluginHandler::CESMRLocationPluginHandler

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

//

CESMRLocationPluginHandler::CESMRLocationPluginHandler( MObjectProvider& aParent )

: iParent(&aParent)

    FUNC_LOG;

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

// CESMRLocationPluginHandler::~CESMRLocationPluginHandler

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

//

CESMRLocationPluginHandler::~CESMRLocationPluginHandler()

    FUNC_LOG;

    delete iWait;

    delete iLocationPlugin;

    delete iLandmark;

    delete iUrlParser;

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

// CESMRLocationPluginHandler::NewL

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

//

        MObjectProvider& aParent )

    FUNC_LOG;

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

// CESMRLocationPluginHandler::ConstructL

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

//

void CESMRLocationPluginHandler::ConstructL()

    FUNC_LOG;

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

// CESMRLocationPluginHandler::HandleCommandL

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

//

TBool CESMRLocationPluginHandler::HandleCommandL( TInt aCommand,

    FUNC_LOG;

            {

                {

                iWait->Start(); // codescanner::callActiveObjectWithoutCheckingOrStopping

                // iLandmark is set in async callback SelectFromMapCompleted

                // from Maps application.

                if ( iLandmark )

                    {

                    UpdateEntryFromLandmarkL( aEntry, *iLandmark );

                    delete iLandmark;

                    iLandmark = NULL;

                }

            break;

            }

            SearchFromLandmarksL( iParent, aEntry );

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

// CESMRLocationPluginHandler::IsCommandAvailableL

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

//

TBool

CESMRLocationPluginHandler::IsCommandAvailableL( TInt aCommand,

                                                 const MESMRCalEntry& aEntry )

    {

    FUNC_LOG;

    TBool res( EFalse );

    switch ( aCommand )

        {

        case EESMRCmdAssignFromMap: //fallthrough

        case EESMRCmdUpdateFromMap:

        case EESMRCmdSearchFromMap:

        case EESMRCmdLandmarks:

            {

            res = ETrue;

            break;

            }

        case EESMRCmdPreviousLocations:

            {

            if ( LocationHistoryManagerL().ItemCount() > 0 )

                {

                res = ETrue;

                }

            break;

            }

        case EESMRCmdShowOnMap:

            {

                {

                res = ETrue;

                }

            break;

            }

        default:

            {

            break;

            }

        }

    return res;

    }

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

// CESMRLocationPluginHandler::StoreLocationToHistoryL

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

//

void CESMRLocationPluginHandler::StoreLocationToHistoryL(

        const MESMRCalEntry& aEntry  )

    {

    FUNC_LOG;

    const CCalEntry& entry = aEntry.Entry();

    const TDesC& entryLocation = entry.LocationL();

    // Store location only if location field contains text.

    if ( entryLocation.Length() > 0 )

        {

        const TDesC& entryDescription = entry.DescriptionL();

        // Search for location url from description.

        TPtrC locationUrl;

        TInt position = UrlParserL().FindLocationUrl( entryDescription,

                                                      locationUrl );

        // If url was not found.

        if ( position < 0 )

            {

            locationUrl.Set( KNullDesC );

            }

        // Check if history item with same location and url

        // is already stored.

        TInt existingHistoryItemIndex = KErrNotFound;

        TInt itemCount = LocationHistoryManagerL().ItemCount();

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

            {

            const MESMRLocationHistoryItem& item =

                iLocationHistoryManager->LocationHistoryItemL( i );

            if ( item.Address().Compare( entryLocation ) == 0 &&

                 item.Url().Compare( locationUrl ) == 0 )

                {

                existingHistoryItemIndex = i;

                break;

                }

            }

        // If history item with same location and url existed

        // update it's position in history array only.

        if ( existingHistoryItemIndex >= 0 )

            {

            // Ownership is not transferred,

            // existing item is already owned by location manager.

            const MESMRLocationHistoryItem& item =

                iLocationHistoryManager->LocationHistoryItemL( existingHistoryItemIndex );

            iLocationHistoryManager->UpdateLocationHistoryL( &item );

            }

        else

            {

            // Create new history item.

            MESMRLocationHistoryItem* historyItem =

                iLocationHistoryManager->CreateLocationHistoryItemL(

                            entryLocation,

                            locationUrl );

            // Store new item to history.

            CleanupDeletePushL( historyItem );

            iLocationHistoryManager->UpdateLocationHistoryL( historyItem );

            CleanupStack::Pop( historyItem );

            }

        }

    }

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

// CESMRLocationPluginHandler::UpdateEntryLocationL

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

//

TBool CESMRLocationPluginHandler::UpdateEntryLocationL( MESMRCalEntry& aEntry,

                                                        const TDesC& aLocation,

    {

    FUNC_LOG;

    TBool entryUpdated = EFalse;

    if ( aLocation.Length() > 0 )

        {

        CCalEntry& entry = aEntry.Entry();

        const TDesC& location = entry.LocationL();

        // Replace old location field content.

        TBool replace = ETrue;

        if ( !aIgnoreQuery

             && location.Length() > 0

             && location != aLocation )

            {

            }

        // If previous location was empty or user selects to

        // replace previous location with new one.

        if (  location.Length() == 0 || replace )

            {

            entry.SetLocationL( aLocation.Left( KMaxLocationTextLength ) );

            }

        else

            {

            // Concatenate new address to existing one

            // Create CPtrCArray for existing and new location strings

            CPtrCArray* strings = new( ELeave ) CPtrCArray( 2 );

            CleanupStack::PushL( strings );

            strings->AppendL( TPtrC( location ) );

            strings->AppendL( TPtrC( aLocation ) );

            HBufC* newLocation =

                StringLoader::LoadLC( R_MEET_REQ_NEW_LOCATION_FORMAT,

                                      *strings );

            entry.SetLocationL( newLocation->Left( KMaxLocationTextLength ) );

            entryUpdated = ETrue;

            CleanupStack::PopAndDestroy( 2, strings );

            }

        }

    return entryUpdated;

    }

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

// From MESMRLocationPluginObserver

// CESMRLocationPluginHandler::SelectFromMapCompleted

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

//

void CESMRLocationPluginHandler::SelectFromMapCompleted( TInt aError,

                                                         CPosLandmark* aLandmark )

    FUNC_LOG;

    if ( iLandmark )

        {

        delete iLandmark;

        iLandmark = NULL;

        }

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

// CESMRLocationPluginHandler::LocationPluginL

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

//

CESMRLocationPlugin& CESMRLocationPluginHandler::LocationPluginL()

    FUNC_LOG;

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

// Creates adress descriptor from a  landmark object

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

//

                                               const CPosLandmark& aLandmark )

    {

    FUNC_LOG;

    CPtrCArray* addressStrings = new( ELeave ) CPtrCArray( 2 );

    CleanupStack::PushL( addressStrings );

    TBool streetAvailable = aLandmark.IsPositionFieldAvailable( EPositionFieldStreet );

    TBool cityAvailable = aLandmark.IsPositionFieldAvailable( EPositionFieldCity );

    if ( streetAvailable )

        {

        TPtrC streetPtr( KNullDesC );

        User::LeaveIfError( aLandmark.GetPositionField( EPositionFieldStreet,

                                                         streetPtr ) );

        if ( streetPtr.Length() > 0 )