/*

* Copyright (c) 2008-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:  Parser class for parsing landmarks to url and vice versa

*

*/

#include "cesmrurlparserpluginimpl.h"

#include "cmrurlparserextension.h"

#include <EPos_CPosLandmark.h>

#include <EPos_CPosLandmarkEncoder.h>

#include <EPos_CPosLandmarkParser.h>

#include <EPos_CPosLmOperation.h>

#include <lbsposition.h>

#include <escapeutils.h>

#include <finditemengine.h>

#include <calentry.h>

#include "emailtrace.h"

namespace

{

_LIT8( KLandmarkUrlMimeType, "maps.ovi.com" );

}

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

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

// CESMRUrlParserPluginImpl::CESMRUrlParserPluginImpl

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

//

CESMRUrlParserPluginImpl::CESMRUrlParserPluginImpl()

    {

    FUNC_LOG;

    }

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

// CESMRUrlParserPluginImpl::NewL

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

//

CESMRUrlParserPluginImpl* CESMRUrlParserPluginImpl::NewL()

    {

    FUNC_LOG;

    CESMRUrlParserPluginImpl* self = CESMRUrlParserPluginImpl::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// CESMRUrlParserPluginImpl::NewLC

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

//

CESMRUrlParserPluginImpl* CESMRUrlParserPluginImpl::NewLC()

    {

    FUNC_LOG;

    CESMRUrlParserPluginImpl* self = new( ELeave ) CESMRUrlParserPluginImpl;

    CleanupStack::PushL( self );

    return self;

    }

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

// CESMRUrlParserPluginImpl::~CESMRUrlParserPluginImpl

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

//

CESMRUrlParserPluginImpl::~CESMRUrlParserPluginImpl()

    {

    FUNC_LOG;

    delete iParser;

    delete iEncoder;

    delete iExtension;

    ReleaseLandmarkResources();

    }

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

// CESMRUrlParserPluginImpl::FindLocationUrl

// Finds location URL from given text input

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

//

TInt CESMRUrlParserPluginImpl::FindLocationUrl(

        const TDesC& aText,

        TPtrC& aUrl )

    {

    FUNC_LOG;

    TInt pos(0);

    TRAPD( error, DoFindLocationUrlL( aText, pos, aUrl ) );

    if ( error != KErrNone )

        {

        return error;

        }

    else

        {

        return pos;

        }

    }

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

// CESMRUrlParserPluginImpl::CreateUrlFromLandmarkL

// Creates location URL from landmark object

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

//

HBufC* CESMRUrlParserPluginImpl::CreateUrlFromLandmarkL(

        const CPosLandmark& aLandmark )

    {

    FUNC_LOG;

    CPosLandmarkEncoder& encoder = InitializeEncoderL();

    CBufBase* buffer = encoder.SetUseOutputBufferL();

    CleanupStack::PushL( buffer );

    encoder.AddLandmarkL( aLandmark );

    CPosLmOperation* operation = encoder.FinalizeEncodingL();

    ExecuteAndDeleteLD( operation );

    // Convert URL to Unicode and escape encode non-ASCII characters

    HBufC* unicode = EscapeUtils::ConvertToUnicodeFromUtf8L( buffer->Ptr( 0 ) );

    CleanupStack::PushL( unicode );

    HBufC* url = EscapeUtils::EscapeEncodeL( *unicode, EscapeUtils::EEscapeNormal );

    CleanupStack::PopAndDestroy( 2, buffer ); // unicode

    //Transfer ownership of url

    return url;

    }

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

// CESMRUrlParserPluginImpl::CreateLandmarkFromUrlL

// Creates landmark object from location URL

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

//

CPosLandmark* CESMRUrlParserPluginImpl::CreateLandmarkFromUrlL(

        const TDesC& aUrl )

    {

    FUNC_LOG;

    CPosLandmark* landmark = NULL;

    // Try to create landmark using landmark parser

    TRAPD( error, landmark = CreateLandmarkFromUrlInternalL( aUrl ) );

    if ( error )

        {

        // Try extension

        landmark = ExtensionL().CreateLandmarkFromUrlL( aUrl );

        }

    //transfer ownership

    return landmark;

    }

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

// CESMRUrlParserPluginImpl::CreateGeoValueLC

// Converts URL to Calendar GEO property

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

//

CCalGeoValue* CESMRUrlParserPluginImpl::CreateGeoValueLC( const TDesC& aUrl )

    {

    FUNC_LOG;

    // Convert URL to landmark

    CPosLandmark* landmark = CreateLandmarkFromUrlL( aUrl );

    CleanupStack::PushL( landmark );

    // Get position data from landmark

    TLocality position;

    User::LeaveIfError( landmark->GetPosition( position ) );

    CleanupStack::PopAndDestroy( landmark );

    // Convert position data to GEO value

    CCalGeoValue* geoVal = CCalGeoValue::NewL();

    CleanupStack::PushL( geoVal );

    geoVal->SetLatLongL( position.Latitude(), position.Longitude() );

    return geoVal;

    }

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

// CESMRUrlParserPluginImpl::InitializeParserL

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

//

CPosLandmarkParser& CESMRUrlParserPluginImpl::InitializeParserL()

    {

    FUNC_LOG;

    if ( !iParser )

        {

        iParser = CPosLandmarkParser::NewL( KLandmarkUrlMimeType );

        }

    return *iParser;

    }

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

// CESMRUrlParserPluginImpl::InitializeEncoderL

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

//

CPosLandmarkEncoder& CESMRUrlParserPluginImpl::InitializeEncoderL()

    {

    FUNC_LOG;

    delete iEncoder;

    iEncoder = NULL;

    iEncoder = CPosLandmarkEncoder::NewL( KLandmarkUrlMimeType );

    return *iEncoder;

    }

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

// CESMRUrlParserPluginImpl::DoFindLocationUrlL

// Finds location URL from given text input

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

//

void CESMRUrlParserPluginImpl::DoFindLocationUrlL(

        const TDesC& aText,

        TInt& aPos,

        TPtrC& aUrl )

    {

    FUNC_LOG;

    aPos = KErrNotFound;

    aUrl.Set( KNullDesC );

    // Search URL from given text

    CFindItemEngine* itemEngine = CFindItemEngine::NewL(

            aText,

            CFindItemEngine::EFindItemSearchURLBin );

    CleanupStack::PushL (itemEngine );

    // For each found item

    CFindItemEngine::SFoundItem item;

    itemEngine->Item( item );

    TInt itemCount = itemEngine->ItemCount();

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

        {

        TPtrC url = aText.Mid( item.iStartPos, item.iLength );

        CPosLandmark* landmark = NULL;

        TRAPD( error, landmark = CreateLandmarkFromUrlL( url ); )

        delete landmark;

        if ( !error ) // Location url found

            {

            aPos = item.iStartPos;

            aUrl.Set( url );

            // Stop iteration

            break;

            }

        else

            {

            itemEngine->NextItem( item );

            }

        }

    CleanupStack::PopAndDestroy( itemEngine );

    if ( aPos <  0 )

        {

        ExtensionL().FindLocationUrlL( aText, aUrl, aPos );

        }

    }

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

// CESMRUrlParserPluginImpl::ExtensionL

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

//

CMRUrlParserExtension& CESMRUrlParserPluginImpl::ExtensionL()

    {

    FUNC_LOG;

    if ( !iExtension )

        {

        iExtension = CMRUrlParserExtension::NewL();

        }

    return *iExtension;

    }

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

// CESMRUrlParserPluginImpl::CreateLandmarkFromUrlInternalL

// Creates landmark object from location URL

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

//

CPosLandmark* CESMRUrlParserPluginImpl::CreateLandmarkFromUrlInternalL(

        const TDesC& aUrl )

    {

    FUNC_LOG;

    // Decode URL and convert it to UTF-8 format

    HBufC* decodedUrl = EscapeUtils::EscapeDecodeL( aUrl );

    CleanupStack::PushL( decodedUrl );

    HBufC8* url = EscapeUtils::ConvertFromUnicodeToUtf8L( *decodedUrl );

    CleanupStack::PopAndDestroy( decodedUrl );

    CleanupStack::PushL( url );

    // Create landmark using correct parser

    CPosLandmarkParser& parser = InitializeParserL();

    parser.SetInputBuffer( *url );

    CPosLmOperation* operation = parser.ParseContentL();

    ExecuteAndDeleteLD( operation );

    CPosLandmark* landmark = parser.LandmarkLC();

    CleanupStack::Pop( landmark );

    CleanupStack::PopAndDestroy( url );

    //transfer ownership

    return landmark;

    }

//EOF