/*

* Copyright (c) 2006-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:    Applications interface class to map and navigation use cases

*

*/

// INCLUDE FILES

#include <AiwGenericParam.h>

#include <epos_poslandmarkserialization.h>

#include <lbsposition.h>

#include <eikenv.h>

#include <StringLoader.h>

#include <lmkui.rsg>

#include <EPos_CPosLandmarkDatabase.h>

#include <EPos_CPosLmOperation.h>

#include <EPos_CPosLandmark.h>

#include <EPos_Landmarks.h>

#include <e32math.h>

#include <AiwServiceHandler.h>

#include <AknQueryDialog.h>

#include <mnaiwservices.h>

#include <AknWaitDialog.h>

#include "clmkdbsearchutils.h"

#include "CLmkSender.h"

#include "CLmkEditorImpl.h"

#include "LmkNotes.h"

#include "clmkmapnavigationinterface.h"

// ================= LOCAL FUNCTIONS =======================

static void CleanupArray(TAny* aArray)

    {

    ( reinterpret_cast<RPointerArray<CPosLandmark>*>( aArray ) )->ResetAndDestroy();

    }

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

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

// CLmkMapNavigationInterface::CLmkMapNavigationInterface

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

// might leave.

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

//

CLmkMapNavigationInterface::CLmkMapNavigationInterface( CPosLandmarkDatabase& aDb )

	: iDb(aDb)

	{

	}

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

// CLmkMapNavigationInterface::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CLmkMapNavigationInterface::ConstructL()

	{

	iAiwServiceHandler = CAiwServiceHandler::NewL();

	iInList = CAiwGenericParamList::NewL();

    iOutList = CAiwGenericParamList::NewL();

	iSearchUtil = NULL;

	iCategoryName = NULL;

	iCategoryId = KPosLmNullItemId;

	iEnv = CEikonEnv::Static();

	}

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

// CLmkMapNavigationInterface::NewL

// Symbian 1st phase constructor can leave.

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

//

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

	{

	CLmkMapNavigationInterface* self = static_cast<CLmkMapNavigationInterface*>(Dll::Tls());

	if(!self)

		{

		self = new (ELeave) CLmkMapNavigationInterface( aDb );

		CleanupStack::PushL( self );

		self->ConstructL();

		CleanupStack::Pop();//self

		Dll::SetTls(self);

		}

	self->iRefCnt++;

	return self;

	}

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

// CLmkMapNavigationInterface::~CLmkMapNavigationInterface

// C++ Destructor

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

//

EXPORT_C CLmkMapNavigationInterface::~CLmkMapNavigationInterface()

	{

	Dll::SetTls( NULL );

	delete iAiwServiceHandler;

    delete iInList;

    delete iOutList;

    delete iCategoryName;

    delete iSearchUtil;

    iLandmarkArray.ResetAndDestroy();

	}

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

// CLmkMapNavigationInterface::HandleNotifyL

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

//

EXPORT_C TInt CLmkMapNavigationInterface::HandleNotifyL( TInt /*aCmdId*/,

														TInt /*aEventId*/,

													    CAiwGenericParamList& /*aEventParamList*/,

													   	const CAiwGenericParamList& /*aInParamList*/ )

	{

	if ( iOutList->Count() )

		{

		const TAiwGenericParam& param = ( *iOutList )[0];

        if ( EGenericParamLandmark == param.SemanticId() )

            {

            TPtrC8 landmarkData( param.Value().AsData() );

            CPosLandmark* lm = PosLandmarkSerialization::UnpackL( landmarkData );

            CleanupStack::PushL( lm );

            SaveLandmarkL( *lm );

            CleanupStack::PopAndDestroy( lm );

            }

        iOutList->Reset();

		}

	return KErrNone;

	}

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

// CLmkMapNavigationInterface::DialogDismissedL

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

//

void CLmkMapNavigationInterface::DialogDismissedL( TInt /*aButtonId*/ )

	{

	CleanupStack::PushL( TCleanupItem( CleanupArray, &iLandmarkArray ) );

	ShowLandmarksOnMapL( iLandmarkArray, iCategoryCommand, iViewType );

	iLandmarkArray.ResetAndDestroy();

	CleanupStack::PopAndDestroy(); //iLandmarkArray

	}

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

// CLmkMapNavigationInterface::SaveLandmarkL

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

//

void CLmkMapNavigationInterface::SaveLandmarkL(CPosLandmark& aLandmark)

	{

	CPosLandmarkDatabase* db = CPosLandmarkDatabase::OpenL();

	CleanupStack::PushL( db );

	CLmkSender* sender = CLmkSender::NewL( *db );

	CleanupStack::PushL( sender );

	CPosLmOperation* operation = db->InitializeL();

	CleanupStack::PushL( operation );

	operation->ExecuteL();

	if( iCategoryId != KPosLmNullItemId )

		{

		aLandmark.AddCategoryL( iCategoryId );

		}

	CLmkEditorImpl *dlg = CLmkEditorImpl::NewL( *db,

											   *sender,

											   CLmkEditorDlg::ELmkAll,

											   CLmkEditorDlg::ELmkEditor,

                                               &aLandmark );

	if( dlg->ExecuteLD() )

	{

	if ( iObserver )

    	{

    	iObserver->HandleLmCreated(aLandmark.LandmarkId());

    	}

	}

	CleanupStack::PopAndDestroy(3);	//sender, operation and db

	iCategoryId = KPosLmNullItemId;

	}

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

// CLmkMapNavigationInterface::ShowLandmarksOnMapL

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

//

EXPORT_C void CLmkMapNavigationInterface::ShowLandmarksOnMapL(RPointerArray<CPosLandmark> &aArray,

															  TInt aCommand,

															  EViewType aViewType)

	{

	CPosLandmark* lm;

	HBufC8* lmBuf;

	iViewType = aViewType;

	// Error checking

	if(!CheckAndDisplayIfLandmarksEmptyL(aArray))

		{

		return;

		}

	iInList->Reset();

	// Pack the landmark into generic parameter

	for(TInt index = 0; index < aArray.Count(); ++index)

		{

		lm = aArray[index];

		lmBuf =PosLandmarkSerialization::PackL( *lm );

		CleanupStack::PushL( lmBuf );

		TAiwGenericParam param( EGenericParamLandmark, TAiwVariant( *lmBuf ) );

    	iInList->AppendL( param );

    	TMnAiwCommonOptionsParam options;

		options.iRunChained = EFalse;

		TPckg<TMnAiwCommonOptionsParam> optionsPack( options );

		TAiwGenericParam optParam( EGenericParamMnCommonOptions, TAiwVariant( optionsPack ) );

		iInList->AppendL( optParam );

    	CleanupStack::PopAndDestroy( lmBuf );

		}

	// Send service command for "Show Landmark on Map"

	iAiwServiceHandler->ExecuteMenuCmdL( aCommand, *iInList, *iOutList, 0, NULL );

	}

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

// CLmkMapNavigationInterface::ShowCategoryOnMapL

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

//

EXPORT_C void CLmkMapNavigationInterface::ShowCategoryOnMapL( TPosLmItemId aCategoryId,

															  TInt aCommand,

															  EViewType aViewType )

	{

	iViewType = aViewType;

	iCategoryCommand = aCommand;

	// This will get deleted in the callback

	if(iSearchUtil == NULL)

		{

		iSearchUtil = CLmkDbSearchUtils::NewL();

		}

	if(iCategoryName != NULL)

		{

		delete iCategoryName;

		iCategoryName = NULL;

		}

	iSearchUtil->GetLandmarksUnderCategoryL( this, aCategoryId );

	if( aCategoryId == KPosLmNullItemId )

		{

		iCategoryName = StringLoader::LoadL( R_LMK_LM_LIST_UNCATEGORISED, iEnv );

		}

	else

		{

		iCategoryName = iSearchUtil->GetCategoryNameL( aCategoryId );

		}

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

	iWaitNote->SetCallback( this );

	iWaitNote->ExecuteLD( R_LMKUI_PROCESSING_WAIT_NOTE );

	iWaitNote = NULL;

	}

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

// CLmkMapNavigationInterface::NavigateToLandmarkL

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

//

EXPORT_C void CLmkMapNavigationInterface::NavigateToLandmarkL( CPosLandmark* aLandmark, TInt aCommand )

	{

	HBufC8* lmBuf = PosLandmarkSerialization::PackL( *aLandmark );

    CleanupStack::PushL( lmBuf );

    TAiwGenericParam param( EGenericParamLandmark, TAiwVariant( *lmBuf ) );

    iInList->Reset();

    iInList->AppendL( param );

    TMnAiwCommonOptionsParam options;

	options.iRunChained = EFalse;

	TPckg<TMnAiwCommonOptionsParam> optionsPack( options );

	TAiwGenericParam optParam( EGenericParamMnCommonOptions, TAiwVariant( optionsPack ) );

	iInList->AppendL( optParam );

    CleanupStack::PopAndDestroy( lmBuf );

    iAiwServiceHandler->ExecuteMenuCmdL( aCommand, *iInList, *iOutList, 0, NULL );

	}

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

// CLmkMapNavigationInterface::GetLandmarkFromMapL

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

//

EXPORT_C void CLmkMapNavigationInterface::GetLandmarkFromMapL( TInt aCommand )

	{

	// This string will be sent to the provider to display it in the map view

    HBufC* buf = StringLoader::LoadLC( R_LM_SELECT_FROM_MAP, iEnv );

	TAiwGenericParam param( EGenericParamRequestText, TAiwVariant( *buf ) );

    iInList->Reset();

    iInList->AppendL( param );

    iOutList->Reset();

	iAiwServiceHandler->ExecuteMenuCmdL( aCommand, *iInList, *iOutList, 0, this );

	CleanupStack::PopAndDestroy(); // buf

	}

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

// CLmkMapNavigationInterface::GetLandmarkFromMapForCategoryL

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

//

EXPORT_C void CLmkMapNavigationInterface::GetLandmarkFromMapForCategoryL( TInt aCommand, TPosLmItemId aCategoryId )

	{

	iCategoryId = aCategoryId;

	GetLandmarkFromMapL( aCommand );

	}

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

// CLmkMapNavigationInterface::GetServiceCmdByMenuCmd

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

//

EXPORT_C TInt CLmkMapNavigationInterface::GetServiceCmdByMenuCmd( TInt aCommand )

	{

	return iAiwServiceHandler->ServiceCmdByMenuCmd( aCommand );

	}

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

// CLmkMapNavigationInterface::AttachAIWInterestL

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

//

EXPORT_C void CLmkMapNavigationInterface::AttachAIWInterestL(TInt aMenuPane, TInt aInterest)

	{

	iAiwServiceHandler->AttachMenuL(aMenuPane, aInterest);

	}

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

// CLmkMapNavigationInterface::AttachAIWInterestL

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

//

EXPORT_C TBool CLmkMapNavigationInterface::HandleMenuOperationL( TInt aResourceId,

															     CEikMenuPane *aMenuPane,

															     TInt aBaseCommand )

	{

	if(iAiwServiceHandler->HandleSubmenuL( *aMenuPane ))

		{

		return ETrue;

		}

	// Checks whether it is aiw menu or not

	if ( iAiwServiceHandler->IsAiwMenu( aResourceId ) )

		{

		CAiwGenericParamList* params = CAiwGenericParamList::NewLC();

		// Adds the aiw plugin menus

		TInt err;

		TRAP( err, iAiwServiceHandler->InitializeMenuPaneL(

              *aMenuPane, aResourceId, aBaseCommand, *params ) );

        CleanupStack::PopAndDestroy(); // params

        return ETrue;

		}

	return EFalse;

	}

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

// CLmkMapNavigationInterface::AttachMenuPaneL

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

//

EXPORT_C void CLmkMapNavigationInterface::AttachMenuPaneL( CEikMenuPane *aMenuPane, TInt aResourceId, TInt aBaseCommand )

	{

	if(iAiwServiceHandler->IsAiwMenu( aResourceId ))

		{

		CAiwGenericParamList* params = CAiwGenericParamList::NewLC();

		TInt err = KErrNone;

        TRAP( err, iAiwServiceHandler->InitializeMenuPaneL(

                   *aMenuPane, aResourceId, aBaseCommand, *params ) );

        CleanupStack::PopAndDestroy( params );

		}

	}

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

// CLmkMapNavigationInterface::DetachInterestL

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

//

EXPORT_C void CLmkMapNavigationInterface::DetachInterestL( TInt aMenuResourceId, TInt aInterestresourceId )

	{

	iAiwServiceHandler->DetachMenu( aMenuResourceId, aInterestresourceId );

	}

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

// CLmkMapNavigationInterface::HandleCategorySearchNotifyL

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

//

void CLmkMapNavigationInterface::HandleCategorySearchNotifyL( RArray<TPosLmItemId> aArray )

	{

	iLandmarkArray.ResetAndDestroy();

	for(TInt i = 0; i < aArray.Count(); ++i)

		{

		CPosLandmark* lmk = iSearchUtil->GetLandmarkForIdL( aArray[i] );

		iLandmarkArray.Append( lmk );

		}

	if(iWaitNote)

		{

		iWaitNote->ProcessFinishedL();

		}

	delete iSearchUtil;

	iSearchUtil = NULL;

	}

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

// CLmkMapNavigationInterface::HandleLmkSearchNotifyL

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

//

void CLmkMapNavigationInterface::HandleLmkSearchNotifyL()

	{

	// Do nothing

	}

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

// CLmkMapNavigationInterface::CheckAndDisplayIfLandmarksEmptyL

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

//

TBool CLmkMapNavigationInterface::CheckAndDisplayIfLandmarksEmptyL( RPointerArray<CPosLandmark> &aArray )

	{

	//Error cases when Landmark(s) is/are empty

	enum ErrorCases

		{

		EErrAllEmpty,        // All selected landmarks are empty

		EErrSomeEmpty,       // Some selected landmarks are empty

		EErrOneEmpty,        // Only one of the selected landmark is empty

		EErrOnlyOneAndEmpty, // Only one landmark is selected and that is empty

		EErrNone 			 // All landmarks have valid coordinate data

		};

	TInt count = aArray.Count();

	TInt err = EErrNone;

	CPosLandmark* lmk;

	TInt numberOfEmptyLmk = 0;

	TInt emptyIndex = 0;

	for(TInt index = 0; index < count; ++index)

		{

		lmk = aArray[index];

		if( IsLandmarkDataEmptyL(*lmk) )

			{

			err = EErrSomeEmpty;

			++numberOfEmptyLmk;

			emptyIndex = index;

			}

		}

	if(numberOfEmptyLmk == count)

		{

		/*

		 * When view type is by lmk view then we make the check for

		 * only one landmark.

		 */

		if( count == 1 && (EByLmkView == iViewType) )

			{

			err = EErrOnlyOneAndEmpty;

			}

		else

			{

			err = EErrAllEmpty;

			}

		}

	else if(err == EErrSomeEmpty && numberOfEmptyLmk == 1)

		{

		err = EErrOneEmpty;

		}

	switch(err)

		{

		case EErrAllEmpty:

			{

			if(EByLmkView == iViewType)

				{

				LmkNotes::AllLandmarksEmptyNoteL( iEnv );

				}

			else

				{

				LmkNotes::CategoryEmptyNoteL( iEnv, iCategoryName->Des());

				}

			return EFalse;

			}

		case EErrSomeEmpty:

			{

    		HBufC* noteText = NULL;

    		if(EByLmkView == iViewType)

    			{

    			noteText = StringLoader::LoadLC( R_LM_SHOW_QUERY_NO_COORDINATES_SEVERAL,

                                  	         	 numberOfEmptyLmk,

                                  	         	 iEnv );

    			}

    		else

				{

				CPtrC16Array* array = new (ELeave) CPtrC16Array(2);

        		array->Reset();

    			CleanupStack::PushL( array );

    			HBufC* ptr = iCategoryName->AllocLC();

    			array->AppendL( *ptr );

        		CArrayFix<TInt>* arrFix = new( ELeave ) CArrayFixFlat<TInt>(2);

        		CleanupStack::PushL( arrFix );

        		arrFix->AppendL(numberOfEmptyLmk);

				noteText = StringLoader::LoadLC( R_LM_SHOW_QUERY_CATEGORY_NO_COORDINATES_SEVERAL,

												 *array,

                                  	         	 *arrFix,

                                  	         	 iEnv );

                CleanupStack::Pop();// noteText

                CleanupStack::PopAndDestroy( 3 ); //ptr, array

                CleanupStack::PushL( noteText );

				}

			CAknQueryDialog* dlg = CAknQueryDialog::NewL( CAknQueryDialog::ENoTone );

			TInt retVal = dlg->ExecuteLD( R_EMPTY_LANDMARKS_DIALOG, *noteText );

			CleanupStack::PopAndDestroy( noteText );

			if(!retVal)

				{

				return EFalse;

				}

			break;

			}

		case EErrOneEmpty:

			{

    		lmk = aArray[emptyIndex];

    		TPtrC landmarkname;

    		lmk->GetLandmarkName( landmarkname );

    		HBufC* noteText = NULL;

    		if(EByLmkView == iViewType)

    			{

    			noteText = StringLoader::LoadLC( R_LM_SHOW_QUERY_NO_COORDINATES_SINGLE,

                                  	         	 landmarkname,

                                  	         	 iEnv );

    			}

    		else

				{

				CPtrC16Array* array = new (ELeave) CPtrC16Array(2);

				array->Reset();

				CleanupStack::PushL( array );

				HBufC* ptr = landmarkname.AllocLC();

				array->AppendL( *ptr );

				array->AppendL( *iCategoryName );