/*

* Copyright (c) 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:   'Set Place' component for retrieving place.

*

*/

#include <evtmgmteditorui.rsg>

#include <aknlistquerydialog.h>

#include <StringLoader.h>

#include <CLmkLandmarkSelectorDlg.h> 

#include <TLmkItemIdDbCombiInfo.h> 

#include <lbsposition.h>

#include <aknnotewrappers.h>

#include <aknmessagequerydialog.h>

#include <AknIconArray.h>       // Icon Array

#include <evteditor.mbg>

#include <AknsUtils.h>

#include <AknsSkinInstance.h>

#include <data_caging_path_literals.hrh>

#include <gulicon.h>            // Gul Icon

#include <eikapp.h>

#include <aknconsts.h>

#include <textresolver.h>

#include "evteditor.h"

#include "evtmgmteditorui.hrh"

#include "evtmgmtuiplacecomponent.h"

#include "evtdebug.h"

#include "evtmgmtuilocsettinglauncher.h"

#include "evtmgmtuilocsettinglauncherobserver.h"

#include "evteditorconsts.h"

#include "evtmgmtuilbtadapter.h"

// CONSTANTS

const TInt KSetPlaceGranularity = 3;

const TInt KMToKMConversion = 1000;

_LIT( KFloatAccuracyFormat, "%.2f" );

static TInt LinkClickedL(TAny* aPtr);

static TInt LinkClickedL(TAny* aPtr)

    {

    CEvtMgmtUiPlaceComponent* self = static_cast<CEvtMgmtUiPlaceComponent*>(aPtr);

    self->LaunchPositioningSettingsL();

    return ETrue;

    }

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

// CEvtMgmtUiPlaceComponent ::NewLC()

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

//

CEvtMgmtUiPlaceComponent* CEvtMgmtUiPlaceComponent::NewLC(const TPtrC aPrevPlace,  TCoordinate& aTriggerLocation )

    {

    CEvtMgmtUiPlaceComponent * self = new (ELeave) CEvtMgmtUiPlaceComponent( aTriggerLocation);

    CleanupStack::PushL(self);

    self->ConstructL(aPrevPlace);

    return self;

    }

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

// CEvtMgmtUiPlaceComponent ::NewL()

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

//

CEvtMgmtUiPlaceComponent* CEvtMgmtUiPlaceComponent::NewL(const TPtrC aPrevPlace,  TCoordinate& aTriggerLocation )

    {

    CEvtMgmtUiPlaceComponent * self = CEvtMgmtUiPlaceComponent::NewLC( aPrevPlace, aTriggerLocation );

    CleanupStack::Pop(self);    

    return self;

    }

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

// CEvtMgmtUiPlaceComponent ::CEvtMgmtUiPlaceComponent()

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

//

CEvtMgmtUiPlaceComponent::CEvtMgmtUiPlaceComponent(  TCoordinate& aTriggerLocation ):iTriggerLocation(aTriggerLocation)

    {   

    iIsDlgOutstanding = EFalse;

    }

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

// CEvtMgmtUiPlaceComponent ::~CEvtMgmtUiPlaceComponent()

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

//

CEvtMgmtUiPlaceComponent::~CEvtMgmtUiPlaceComponent()

    {    

    delete iPlace;

    iPlace = NULL;

    if( iMapAdapter )

        {

        delete iMapAdapter;

        iMapAdapter = NULL;

        }    

    if( iLocationServiceAdapter )

        {

        delete iLocationServiceAdapter;

        iLocationServiceAdapter = NULL;

        }

    if( iWaitDialogLauncher )

        {

        delete iWaitDialogLauncher;

        iWaitDialogLauncher = NULL;

        }

    if(iPosSetLauncher)

        {

        delete iPosSetLauncher;

        iPosSetLauncher = NULL;

        }

    if( iIsDlgOutstanding )

        {

        TKeyEvent key;

        key.iCode = EKeyEscape;

        key.iModifiers = 0;

        TRAP_IGNORE( CEikonEnv::Static()->SimulateKeyEventL(key, EEventKey)) ;

        }

    }

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

// CEvtMgmtUiPlaceComponent ::ConstructL()

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

//

void CEvtMgmtUiPlaceComponent ::ConstructL(const TPtrC aPrevPlace)

    {

    iPlace = aPrevPlace.AllocL();

    }

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

// CEvtMgmtUiPlaceComponent::DisplayPlacePopupDlg()

// It is used as a wrapper class to trap leaving function DisplayPlacePopupDlgL()

// @param[in] aStatus - status which will contain success/failure state

//                       based on retrieval of location is successful or failed

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

//

void CEvtMgmtUiPlaceComponent::DisplayPlacePopupDlg( TRequestStatus& aStatus )

    {

    EVTUIDEBUG("+ CEvtMgmtUiPlaceComponent::DisplayPlacePopupDlg()" );

    iStatus = &aStatus;

    TInt response(0);

    // show 'set place' popup dialog and retrieve location information

    TRAPD( err, response = DisplayPlacePopupDlgL() );

    if( err != KErrNone )// if the request is failed

        {

        iIsDlgOutstanding = EFalse;

		//TRAP_IGNORE( ResolveErrorL( err ) );

        User::RequestComplete( iStatus, err );

        }

    else 

        {

        //if from landmark, complete the request otherwise wait till asychronous 

        //operation is completed

        if( response == EEvtMgmtUiSetPlaceLandmark ) 

            {

            if( iStatus )

                User::RequestComplete( iStatus, KErrNone );

            }

        //if dialog is cancelled

        if( response == KErrCancel ) 

            {

            if( iStatus )

                User::RequestComplete( iStatus, KErrCancel );

            }

        }

    EVTUIDEBUG("- CEvtMgmtUiPlaceComponent::DisplayPlacePopupDlg()" );

    }

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

// CEvtMgmtUiPlaceComponent::Place()

// returns place value

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

TPtrC CEvtMgmtUiPlaceComponent::Place() const

    {

    if(iPlace)

        return *iPlace;

    else

        return KNullDesC();

    }

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

// CEvtMgmtUiPlaceComponent::TriggerLocation()

// returns location recentrly retrieved

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

TCoordinate& CEvtMgmtUiPlaceComponent::TriggerLocation() const

    {

    return iTriggerLocation;

    }

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

// CEvtMgmtUiPlaceComponent::HandleMapAndNavigationResonseL()

// Derived from MEvtMgmtUiMapAndNavigationObserver

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

//

void CEvtMgmtUiPlaceComponent::HandleMapAndNavigationResponseL( TInt aErrorCode, const TPtrC aPlace, TCoordinate aTriggerLocation )

    {

    EVTUIDEBUG("+ CEvtMgmtUiPlaceComponent::HandleMapAndNavigationResponseL()" );

    if( aErrorCode == KErrNone )

        {

        //if successful , set place and location to those retrieved from map

        if(aPlace.Length())

            {

            delete iPlace;

            iPlace = NULL;

            iPlace = aPlace.AllocL();     

            }

        // Get Place

        aErrorCode = GetPlaceL();

        iTriggerLocation = aTriggerLocation;

        }

    // complete 'set place' operation selected from map

    if(iStatus)

        User::RequestComplete( iStatus, aErrorCode );

    EVTUIDEBUG("- CEvtMgmtUiPlaceComponent::HandleMapAndNavigationResponseL()" );

    }

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

// CEvtMgmtUiPlaceComponent::HandleLocationServiceResponseL()

// Derived from MEvtMgmtUiLocationServiceObserver

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

//

void CEvtMgmtUiPlaceComponent::HandleLocationServiceResponseL( const TInt aStatus )

    {    

    EVTUIDEBUG1("+ CEvtMgmtUiPlaceComponent::HandleLocationServiceResponseL() - %d", aStatus );

    TInt err = aStatus;

    // Stop the running wait dialog

    TInt buttonId = iWaitDialogLauncher->StopWaitDialogL();

    if( EEikBidCancel != buttonId ) // if busy dialog is not cancelled

        {

        switch( aStatus )

            {

            case KErrNone:

            case KPositionPartialUpdate:

                {    

                if(iLocationServiceAdapter)    

                    {

                    EVTUIDEBUG("========== Retrieving current location ========" );

                    //Set location

                    iTriggerLocation = iLocationServiceAdapter->CurrentPosition();    

                    TPosition pos = iLocationServiceAdapter->CurrentPosition();

                    if ( !Math::IsNaN( pos.HorizontalAccuracy() ) )

                        DisplayAccuracyNoteL(pos);

                    else

                        DisplayAccuracyNoteL();

                    // Get Place

                    err = GetPlaceL();

                    }         

                EVTUIDEBUG("========== Retrieved current location ========" );

                break;

                }

            default:

                {

                break;

                }

            }

        // complete 'set place' operation selected from current location

        if( iStatus  )

            User::RequestComplete( iStatus, err );

        }

    else

        {

        TRAP( err, DisplayErrorNoteL( R_EVTUI_CANCEL_REQUESTING_LOCATION ) );       

        EVTUIDEBUG1("Erro while displaying error note =%d", err );

        // complete 'set place' operation selected from current location

        if( iStatus  )

            User::RequestComplete( iStatus, KErrCancel );

        }

    //Delete LocAcq object

    if( iLocationServiceAdapter )

         {

         delete iLocationServiceAdapter;

         iLocationServiceAdapter = NULL;

         }     

    EVTUIDEBUG("- CEvtMgmtUiPlaceComponent::HandleLocationServiceResponseL()");

    }

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

// CEvtMgmtUiPlaceComponent::HandleLocationServiceErrorL()

// Derived from MEvtMgmtUiLocationServiceObserver

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

//

void CEvtMgmtUiPlaceComponent::HandleLocationServiceErrorL( TInt aErrorCode )

    {

    EVTUIDEBUG1("+ CEvtMgmtUiPlaceComponent::HandleLocationServiceErrorL - %d", aErrorCode );

    //Error handling   

    switch( aErrorCode )

        {

        case KErrNotFound: //if no psy selected

            {

		    //Delete wait dialog

		    if( iWaitDialogLauncher )

		        iWaitDialogLauncher->StopWaitDialogL();

            if( DisplayNoPositioningMethodInfoNoteL( R_EVTUI_MESSAGE_QUERY ) ) //if Open is pressed

                {

                return;

                }            

            break;

            }

        case KErrCancel:

            {                        

            //Delete wait dialog

            if( iWaitDialogLauncher )

                iWaitDialogLauncher->StopWaitDialogL();

            TRAPD( err, DisplayErrorNoteL( R_EVTUI_CANCEL_REQUESTING_LOCATION ) );       

            EVTUIDEBUG1("Erro while displaying error note =%d", err );

            break;

            }

        case KErrTimedOut:

        default:

            {

		    //Delete wait dialog

		    if( iWaitDialogLauncher )

		        iWaitDialogLauncher->StopWaitDialogL();

            //disply retry message

            CAknErrorNote* errNote = new(ELeave) CAknErrorNote( ETrue );

            TBuf<128> msg;

            CEikonEnv::Static()->ReadResourceAsDes16L(msg, R_EVTUI_RETRY_REQUESTING_LOCATION );        

            errNote->ExecuteLD( msg );

            break;

            }

        }

    //delete LocAcq object

    if( iLocationServiceAdapter )

        {

        delete iLocationServiceAdapter;

        iLocationServiceAdapter = NULL;

        }

    // Complete 'set place' operation selected from current location with failure

    User::RequestComplete( iStatus, KErrCancel );

    EVTUIDEBUG("- CEvtMgmtUiPlaceComponent::HandleLocationServiceErrorL()");

    }

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

// CEvtMgmtUiPlaceComponent::HandleDialogDismissed()

// Derived from MEvtMgmtUiWaitDialogLauncherObserver

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

//

void CEvtMgmtUiPlaceComponent::HandleDialogDismissed( TInt aButtonId )

    {

    EVTUIDEBUG("+ CEvtMgmtUiPlaceComponent::HandleDialogDismissed()");

    if( EEikBidCancel == aButtonId && iLocationServiceAdapter &&

            iLocationServiceAdapter->IsActive() )

        {

        EVTUIDEBUG("wait dialog is dismissed manually" );

        //Cancel Outstanding Request

        iLocationServiceAdapter->CancelRequest();

        }

    EVTUIDEBUG("- CEvtMgmtUiPlaceComponent::HandleDialogDismissed()");

    }

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

// CEvtMgmtUiPlaceComponent::NotifyLocSettingLaucherChangeL()

// Derived from MEvtMgmtUiLocSettingsLauncherObserver

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

//

void CEvtMgmtUiPlaceComponent::NotifyLocSettingLaucherChangeL( TInt /*aErrorCode*/ )

    {

    // Nothing to do.

    }

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

// void CEvtMgmtUiPlaceComponent::DisplayErrorNoteL()

// It is used to display error note.

// @param[in] aResourceId - resource ID of the text to be displayed on error note.

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

//

void CEvtMgmtUiPlaceComponent::DisplayErrorNoteL(TInt aResourceId )

    { 

    EVTUIDEBUG("+ CEvtMgmtUiPlaceComponent::DisplayErrorNoteL" );

    CAknErrorNote* errNote = new(ELeave) CAknErrorNote( ETrue );

    TBuf<32> msg;

    CEikonEnv::Static()->ReadResourceAsDes16L(msg, aResourceId );

    iIsDlgOutstanding = ETrue;

    errNote->ExecuteLD( msg );

    iIsDlgOutstanding = EFalse;

    EVTUIDEBUG("- CEvtMgmtUiPlaceComponent::DisplayErrorNoteL" );

    }

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

// TInt CEvtMgmtUiPlaceComponent::GetPlaceL()

// Displays the Query dialog for getting place.

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

//

TInt CEvtMgmtUiPlaceComponent::GetPlaceL()

    {

    EVTUIDEBUG("+ CEvtMgmtUiPlaceComponent::GetPlaceL()");

    HBufC* place = HBufC::NewLC( KPlaceMaxLength );

    place->Des().Copy( *iPlace );

    TPtr placePtr(place->Des());

    TInt ret = KErrCancel;

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

    CAknTextQueryDialog* dlg = new(ELeave) CAknTextQueryDialog( placePtr ,*prompt, CAknQueryDialog::ENoTone );

    if( EEikBidOk == dlg->ExecuteLD( R_EVTUI_PLACE_DATA_QUERY ))

        {

        delete iPlace;

        iPlace = NULL;

        iPlace = place->AllocL();

        ret = KErrNone;

        }

    CleanupStack::PopAndDestroy(2); // prompt, place

    EVTUIDEBUG("- CEvtMgmtUiPlaceComponent::GetPlaceL()");

    return ret;

    }

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

// TInt CEvtMgmtUiPlaceComponent::LaunchPositioningSettingsL()

// It is used to launch position settings

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

//

void CEvtMgmtUiPlaceComponent::LaunchPositioningSettingsL()

    {

    EVTUIDEBUG("+ CEvtMgmtUiPlaceComponent::LaunchPositioningSettingsL()");

    if(!iPosSetLauncher)

          {

          iPosSetLauncher = CEvtMgmtUiLocSettingsLauncher::NewL();                

          }

    iPosSetLauncher->SetObserver(this);

    iPosSetLauncher->LaunchL();

    EVTUIDEBUG("- CEvtMgmtUiPlaceComponent::LaunchPositioningSettingsL()");

    }

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

// CEvtMgmtUiPlaceComponent::DisplayPlacePopupDlgL()

// It is used to display 'set place' popup dialog and retrieve place 

// using selected method.

// @ret it returns the option selected.

//      it leaves with KErrCancel, if popup dialog is cancelled.

//      it may leave with other errors, if retrieval of place fails.     

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

//

TInt CEvtMgmtUiPlaceComponent::DisplayPlacePopupDlgL()

    {

    EVTUIDEBUG("+ CEvtMgmtUiPlaceComponent::DisplayPlacePopupDlgL()");

    TInt index;

    const TInt KCpIconIndex = 0;

    const TInt KLmkIconIndex = 1;

    const TInt KMapIconIndex = 2;

    const TInt KIconTextLength = 1;

    _LIT(KTab, "\t");  

    HBufC* dummy = NULL;

    // Retrieve number of landmarks stored in landmark database.

    TInt lmks = LandmarksL();

    //Retrive strings for popup dialog.

    //Current Location

    dummy = StringLoader::LoadLC(R_EVTUI_CREATENEW_FORM_PLACEPOPUPOPTION_CURRENTPLACE);

    HBufC* cp = HBufC::NewL( KIconTextLength + KTab().Length() + 

                        dummy->Length() + KTab().Length( )+ KTab().Length() );    

    TPtr ptrDummy = cp->Des();    

    ptrDummy.Num(KCpIconIndex);

    ptrDummy.Append(KTab);

    ptrDummy.Append(*dummy);

    ptrDummy.Append(KTab);

    ptrDummy.Append(KTab);

    CleanupStack::PopAndDestroy(dummy);

    CleanupStack::PushL(cp);

    //Landmark

    dummy   = StringLoader::LoadLC(R_EVTUI_CREATENEW_FORM_PLACEPOPUPOPTION_LANDMARK);

    HBufC* lmk = HBufC::NewL( KIconTextLength + KTab().Length() + 

                           dummy->Length() + KTab().Length( )+ KTab().Length() );

    ptrDummy.Set(lmk->Des());

    ptrDummy.Num(KLmkIconIndex);

    ptrDummy.Append(KTab);

    ptrDummy.Append(*dummy);

    ptrDummy.Append(KTab);

    ptrDummy.Append(KTab);

    CleanupStack::PopAndDestroy(dummy);

    CleanupStack::PushL(lmk);

    //Map

    dummy   = StringLoader::LoadLC(R_EVTUI_CREATENEW_FORM_PLACEPOPUPOPTION_FROMMAP);

    HBufC* map = HBufC::NewL( KIconTextLength + KTab().Length() + 

                           dummy->Length() + KTab().Length( )+ KTab().Length() );    

    ptrDummy.Set(map->Des());

    ptrDummy.Num(KMapIconIndex);

    ptrDummy.Append(KTab);

    ptrDummy.Append(*dummy);

    ptrDummy.Append(KTab);

    ptrDummy.Append(KTab);

    CleanupStack::PopAndDestroy(dummy);

    CleanupStack::PushL(map);

    HBufC* title = StringLoader::LoadLC(R_EVTUI_CREATENEW_FORM_PLACEPOPUP_TITLE);