/*

* Copyright (c) 2007 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:   Controller class for location UI behavior

 *

*/

//debug

#include "calendarui_debug.h"

#include "calenlocationui.h"

#include "calencontroller.h"

#include <calencommands.hrh>

#include "calenlocationactiveselector.h"

#include "calenglobaldata.h"

#include "calenlocationutil.h"

#include <Calendar.rsg>

#include <calencommonui.rsg>

#include <calentry.h>

#include <CalenInterimUtils2.h>

#include <aknnotewrappers.h>

#include <aknselectionlist.h>

#include <aknPopup.h>

#include <aknlists.h>

#include <StringLoader.h>

#include <sysutil.h>

#include <eikenv.h>

#include <mnmapview.h>

#include <mnproviderfinder.h>

#include <EPos_CPosLandmark.h>

#include <lbsposition.h>

#include <e32math.h>

#include <calencontext.h>

#include <AknUtils.h>

// CONSTANTS and MACROS

_LIT(KComma, ",");

_LIT(KNokiaVendorName, "Nokia gate5 GmbH");

const TInt KCalenMaxTextEditorLength(160);

_LIT( KReplaceWhitespaceChars, "\x0009\x000A\x000B\x000C\x000D\x2028\x2029" );

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

// CCalenLocationUi::NewL

// First stage construction

// (other items were commented in a header).

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

//

CCalenLocationUi* CCalenLocationUi::NewL( CCalenController& aController )

    {

    TRACE_ENTRY_POINT;

    CCalenLocationUi* self = new(ELeave) CCalenLocationUi( aController );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    TRACE_EXIT_POINT;

    return self;

    }

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

// CCalenLocationUi::~CCalenLocationUi

// Destructor

// (other items were commented in a header).

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

//

CCalenLocationUi::~CCalenLocationUi()

    {

    TRACE_ENTRY_POINT;

    if(iMapView)

       {

       iMapView->Cancel();

       iMapView->ResetLandmarksToShow();

       delete iMapView;

       iMapView = NULL;    

       }

    ReleaseLandmarkResources();

    iController.CancelNotifications( this );

    if(iLocationSelector)

	    {

	    delete iLocationSelector;	

	    }

	if(iCurrLocAcquisition)

		{

		delete iCurrLocAcquisition;	

		}

	if( iGlobalData )

        {

        iGlobalData->Release();

        }

    if(iLocationText)

    	{

    	delete iLocationText;

    	iLocationText = NULL;

    	}

    TRACE_EXIT_POINT;

    }

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

// CCalenLocationUi::CCalenLocationUi

// Constructor

// (other items were commented in a header).

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

//

CCalenLocationUi::CCalenLocationUi( CCalenController& aController )

    : iController( aController )

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    }

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

// CCalenLocationUi::ConstructL

// Second stage construction

// (other items were commented in a header).

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

//

void CCalenLocationUi::ConstructL()

    {

    TRACE_ENTRY_POINT;

    isCurrLocAvailable = EFalse;

    iGlobalData = CCalenGlobalData::InstanceL();

	iLocationSelector = CCalenLocationActiveSelector::NewL( *this, *this, *iGlobalData);

	RArray<TCalenNotification> notificationArray;

	notificationArray.Append( ECalenNotifyEntryClosed );

  	notificationArray.Append( ECalenNotifyInstanceSaved );

    notificationArray.Append( ECalenNotifyDialogClosed );

    notificationArray.Append( ECalenNotifyMapClosed );

    notificationArray.Append( ECalenNotifyCancelMapLaunch );

    notificationArray.Append( ECalenNotifyEntrySaved );

    notificationArray.Append( ECalenNotifyEntryDeleted );

	iController.RegisterForNotificationsL(this, notificationArray);

	notificationArray.Reset();

    TRACE_EXIT_POINT;

    }

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

// CCalenLocationUi::HandleActionUiCommandL

// Handles action ui commands

// (other items were commented in a header).

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

//

TBool CCalenLocationUi::HandleCommandL( const TCalenCommand& aCommand )

    {

    TRACE_ENTRY_POINT;

    if(isRequestPending)

	    {

	    // Already one request is being processed,

	    // Ignore this new request

	    return EFalse;	

	    }

    TBool continueCommand(EFalse);

    TInt command = aCommand.Command();

    switch ( command )

	    {

	    case ECalenGetLocationAndSave:

	    	isGetLocationAndSave = ETrue;

		    LaunchMapL();

		    break;

	    case ECalenGetLocation:

		    LaunchMapL();

		    break;

	    case ECalenShowLocation:

	    	ShowLocationOnMapL();

	    	break;

	    case ECalenGetLocationAndReplace:

	        isGetLocationAndSave = ETrue;

	        isReplaceLocation = ETrue;

            LaunchMapL();

            break;

	    case ECalenShowLocationQuery:

	        {

	        TInt userResponse = ShowDefineLocationQueryL();

	        if(userResponse)

	            {

	            isGetLocationAndSave = ETrue;

	            LaunchMapL();

	            }

	        else

	            {

	            iController.BroadcastNotification(ECalenNotifyMapClosed);

	            }

	        }

	        break;

	    default:

	    	break;

	    }

	TRACE_EXIT_POINT;

    return continueCommand;

    }

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

// CCalenLocationUi::CalenCommandHandlerExtensionL

//

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

//

TAny* CCalenLocationUi::CalenCommandHandlerExtensionL( TUid /*aExtensionUid*/ )

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return NULL;

    }

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

// CCalenLocationUi::HandleNotification

// Handle notifications

// (other items were commented in a header).

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

//

void CCalenLocationUi::HandleNotification(const TCalenNotification aNotification )

    {

    TRACE_ENTRY_POINT;

    MCalenContext& context = iGlobalData->Context();

    switch( aNotification )

	    {

	    case ECalenNotifyEntryClosed:  // issued when new entry dialog is cancelled

        case ECalenNotifyEntrySaved:

        case ECalenNotifyInstanceSaved:

        case ECalenNotifyDialogClosed:

        case ECalenNotifyEntryDeleted:

        	{

        	if(isRequestPending)

	        	{

	        	iCurrLocAcquisition->CancelRequest();

	        	delete 	iCurrLocAcquisition;

	        	iController.BroadcastNotification(ECalenNotifyMapClosed);

	        	}

        	// Delete the landmark object from context

        	context.ResetLandMark();

        	}

        	break;

	    case ECalenNotifyMapClosed:

	    	// Repopulate the current view

	    	if(isGetLocationAndSave)

		    	{

		    	isGetLocationAndSave = EFalse;

	    		PIM_TRAPD_HANDLE(iController.IssueCommandL( ECalenStartActiveStep ));	

		    	}

	    	break;

	    case ECalenNotifyCancelMapLaunch:

	    	{

	    	// Cancel any pending async requests

	    	if(iMapView)

               {

               iMapView->Cancel();

               iMapView->ResetLandmarksToShow();

               delete iMapView;

               iMapView = NULL;    

               }

            ReleaseLandmarkResources();

	    	iLocationSelector->DoCancel();

	    	if(iProvider)

	    	    {

    	    	delete iProvider;

    			iProvider = NULL;

	    	    }

	    	}

	    	break;

	    }

    TRACE_EXIT_POINT;

    }

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

// CCalenLocationUi::RequestCurrenLocationL

// It issues asyn request to get the coordinates for current location

// (other items were commented in a header).

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

//

void CCalenLocationUi::RequestCurrenLocationL()

    {

    TRACE_ENTRY_POINT;

    iCurrLocAcquisition = CCalenCurrentLocationAcquisition::NewL( *this);                

    isRequestPending = ETrue;

    iCurrLocAcquisition->RequestL();

    TRACE_EXIT_POINT;

    }

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

// CCalenLocationUi::NotifyCurrentLocationL

// Callback which gets called when async request is complete.

// (other items were commented in a header).

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

//

void CCalenLocationUi::NotifyCurrentLocationL()

	{

	TRACE_ENTRY_POINT;

	// Asyn request complete, now get the coordinates of current location

	TPosition currPosition = iCurrLocAcquisition->CurrentPosition();	

	delete iCurrLocAcquisition;

	iCurrPosition = currPosition;

	isCurrLocAvailable = ETrue;

	isRequestPending = EFalse;	

	LaunchMapL(currPosition);

	TRACE_EXIT_POINT;

	}

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

// CCalenLocationUi::NotifyCurrentLocationL

// Callback function that gets called if there is any error

// while fetching coordinates for current location

// (other items were commented in a header).

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

//

void CCalenLocationUi::NotifyErrorL(const TInt /* errorCode */)

	{

	TRACE_ENTRY_POINT;

	delete iCurrLocAcquisition;

	isRequestPending = EFalse;

	// Error occurred, launch the map with default values

	LaunchMapL();

	TRACE_EXIT_POINT;	

	}

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

// CCalenLocationUi::LaunchMapL

// Launches Map with coords of current location 

// for the user to select the event location

// (other items were commented in a header).

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

// 

void CCalenLocationUi::LaunchMapL(TPosition& aPosition)

	{

	TRACE_ENTRY_POINT;

    const CMnProvider::TServices neededServices = CMnProvider::EServiceNavigation |

    											  CMnProvider::EServiceMapView ; 									  

	iProvider = GetFirstProviderL(neededServices);

	iLocationSelector->SelectL( *iProvider, aPosition, !isGetLocationAndSave );

	TRACE_EXIT_POINT;

	}

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

// CCalenLocationUi::LaunchMapL

// Launches Map with default coords for the user to select the event location

// (other items were commented in a header).

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

// 

void CCalenLocationUi::LaunchMapL()

	{

	TRACE_ENTRY_POINT;

	const CMnProvider::TServices neededServices = CMnProvider::EServiceNavigation |

	                                                  CMnProvider::EServiceMapView ;                                      

	iProvider = GetFirstProviderL(neededServices);

	MCalenContext& context = iGlobalData->Context();

    CPosLandmark* landmark = context.GetLandMark();

	if(landmark)

	    {

	        {

	        // entry has proepr geovalues, launch the map with that location at the centre

	        iLocationSelector->SelectL( *iProvider, landmark );

	        }

	    context.ResetLandMark();

	    }

	else if(isGetLocationAndSave) // If issued from Day view or event viewer

	    {

	    // Get the entry

		TCalLocalUid instanceId = context.InstanceId().iEntryLocalUid;

		CCalEntry* entry = iGlobalData->EntryViewL(context.InstanceId().iColId)->FetchL(instanceId);

		if(entry)

			{

			CleanupStack::PushL( entry );

			CCalGeoValue* geoValue = entry->GeoValueL();

			TPtrC location = entry->LocationL();

			if(geoValue)

				{

				// entry has proepr geovalues, launch the map with that location at the centre

				TReal latitude;

                TReal longitude;

                geoValue->GetLatLong(latitude, longitude);

                TPosition position;

                position.SetCoordinate(latitude, longitude);

                CPosLandmark* landmarkToShow = CPosLandmark::NewL();

                //TPtrC location = entry->LocationL();

                landmarkToShow->SetLandmarkNameL(location);

                landmarkToShow->SetPositionL(position);

				delete geoValue;	

				iLocationSelector->SelectL( *iProvider, landmarkToShow );

				delete landmarkToShow;

				}

			else if(location.Length())

			    {

                TBuf<KCalenMaxTextEditorLength> locationBuf;

                locationBuf.Copy(location);

                AknTextUtils::ReplaceCharacters(locationBuf, KReplaceWhitespaceChars, TChar(' '));

			    // Add dummy landmark, so that Maps search box will get filled

			    CPosLandmark* landmarkToShow = CPosLandmark::NewL();

                landmarkToShow->SetLandmarkNameL(locationBuf);

                iLocationSelector->SelectL( *iProvider, landmarkToShow );

                delete landmarkToShow;

			    }

			else{

			    iLocationSelector->SelectL( *iProvider, NULL );

			    }

			CleanupStack::PopAndDestroy( entry );

			}

		}

	else

	    {

	    iLocationSelector->SelectL( *iProvider, NULL );

	    }

	TRACE_EXIT_POINT;

	}

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

// CCalenLocationUi::ShowLocationOnMapL

// Launches Map for the user to show the event location

// (other items were commented in a header).

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

// 

void CCalenLocationUi::ShowLocationOnMapL()

	{

	TRACE_ENTRY_POINT;

	const CMnProvider::TServices neededServices = CMnProvider::EServiceMapView ; 

	iProvider = GetFirstProviderL(neededServices);

	iMapView = CMnMapView::NewChainedL( *iProvider );

	iMapView->SetExitObserverL(*this);

    // Get the entry

    MCalenContext& context = iGlobalData->Context();

	CPosLandmark* landmark = context.GetLandMark();

	RPointerArray<CPosLandmark> landmarks;

	    if(landmark)

	        {

	        landmarks.Append(landmark);

	        iMapView->AddLandmarksToShowL(landmarks);

	        context.ResetLandMark();

	        }

	    else

	        {

	        TCalLocalUid instanceId = context.InstanceId().iEntryLocalUid;

            CCalEntry* entry = iGlobalData->EntryViewL(context.InstanceId().iColId)->FetchL(instanceId);

            if(entry)

                {

                CleanupStack::PushL( entry );

                CCalGeoValue* geoValue = entry->GeoValueL();

                if(geoValue)

                    {

                    TReal latitude;

                    TReal longitude;

                    geoValue->GetLatLong(latitude, longitude);

                    TPosition position;

                    position.SetCoordinate(latitude, longitude);

                    CPosLandmark* landmarkToShow = CPosLandmark::NewL();

                    TPtrC location = entry->LocationL();

                    landmarkToShow->SetLandmarkNameL(location);

                    landmarkToShow->SetPositionL(position);

                    landmarks.Append(landmarkToShow);

                    iMapView->AddLandmarksToShowL(landmarks);

                    delete landmarkToShow;

                    delete geoValue;    

                    }

                CleanupStack::PopAndDestroy( entry );

                }

	        } 

	_LIT(text, "Meeting Location");

    // start request

    iMapView->SetCustomRequestTextL(text);

	iMapView->ShowMapL(); 

	TRACE_EXIT_POINT;

	}

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

// CCalenLocationUi::HandleSelectionCompletedL

// Handles user selection for the event location on the map

// (other items were commented in a header).

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

// 	

void CCalenLocationUi::HandleSelectionCompletedL( CMnMapView& aMapView, TInt aError )

    {

    TRACE_ENTRY_POINT;

    // Forcefully broadcast app foreground notification, so that

    // ECalenMapState would be current state

    if(!iController.IsFasterAppFlagEnabled())

        {

    	iController.BroadcastNotification(ECalenNotifyAppForegrounded);	

        }

    // selection is done, analyze error code first...

    if ( !aError )

        {

        // retrieve result

        switch ( aMapView.SelectionResultType() )

            {

            case CMnMapView::ESelectionFreeLandmark: