/*

* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:  CLandmarkInterface class implementation

 *

*/

//INCLUDES

#include <e32math.h>

#include <liwcommon.h>

#include <EPos_CPosLandmarkParser.h>

#include <EPos_CPosLandmarkEncoder.h>

#include <EPos_CPosLandmarkSearch.h>

#include <EPos_CPosLmCompositeCriteria.h>

#include <EPos_CPosLmNearestCriteria.h>

#include <EPos_CPosLmTextCriteria.h>

#include <EPos_CPosLmAreaCriteria.h>

#include <EPos_CPosLmCategoryCriteria.h>

#include <EPos_CPosLmCatNameCriteria.h>

#include <EPos_CPosLmDatabaseManager.h>

#include <EPos_TPosLmDatabaseSettings.h>

#include <utf.h>

#include "landmarkliwparams.hrh"

#include "landmarkinterface.h"

#include "landmarkservice.h"

#include "clandmarkfilter.h"

#include "clandmarkiterable.h"

#include "clandmarkcategoryiterable.h"

#include "clandmarkdatabaseiterable.h"

#include "clandmarkobserver.h"

#include "clandmarkcallbackmap.h"

#include "../../inc/serviceerrno.h"

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

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

// CLandmarkInterface::NewL()

// Two-phased constructor.

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

//

CLandmarkInterface* CLandmarkInterface::NewL( )

    {

    CLandmarkInterface* self = new (ELeave) CLandmarkInterface();

    CleanupStack::PushL (self );

    self->ConstructL ( );

    CleanupStack::Pop (self );

    return self;

    }

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

// CLandmarkInterface::~CLandmarkInterface()

// Destructor.

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

//

CLandmarkInterface::~CLandmarkInterface( )

    {

    delete iService;

    delete iObserver;

    delete iErrMsg;

    delete iId;

    iCallbackMap.ResetAndDestroy ( );

    iCallbackMap.Close ( );

    ReleaseLandmarkResources ( );

    }

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

// CLandmarkInterface::CLandmarkInterface()

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

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

//

CLandmarkInterface::CLandmarkInterface( )

    {

    }

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

// CLandmarkFilter::ConstructL()

// Symbian 2nd phase constructor can leave.

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

//

void CLandmarkInterface::ConstructL( )

    {

    //instantiate the service class

    iService = CLandmarkService::NewL ( );

    //register observer for async requests

    iObserver = CLandmarkObserver::NewL ( this );

    iService->RegisterObserver (iObserver );

    }

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

// CLandmarkInterface::ExecuteCmdL( const TDesC8& aCmdName,

//                           const CLiwGenericParamList& aInParamList,

//                           CLiwGenericParamList& aOutParamList,

//                           TUint aCmdOptions,

//                           MLiwNotifyCallback* aCallback )

// This function is called by the user to handle the service commands.

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

//

void CLandmarkInterface::ExecuteCmdL( const TDesC8& aCmdName,

        const CLiwGenericParamList& aInParamList,

        CLiwGenericParamList& aOutParamList, TUint aCmdOptions,

        MLiwNotifyCallback* aCallback )

    {

    if ( iErrMsg )

        {

        delete iErrMsg;

        iErrMsg = NULL;

        }

    if( iId )

    	{

    	delete iId;

    	iId = NULL;

    	}

    //check if any of the service API's leave

    TRAPD(err,SwitchCmdL(aCmdName,aInParamList,aOutParamList,

                    aCmdOptions,aCallback))

    ;

    TInt SapiErr = SErrNone;

    if (err )

        {

        SapiErr = SapiError (err );

        }

    aOutParamList.AppendL (TLiwGenericParam (KErrorCode, TLiwVariant ((TInt32)SapiErr ) ) );

    if ( iErrMsg )

        {

        aOutParamList.AppendL (TLiwGenericParam (KErrorMsg,

                TLiwVariant (iErrMsg ) ) );

        }

    }

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

// CLandmarkInterface::SapiError( )

// This function is called by the user to get mapped SAPI generic error code

// from symbian error codes .

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

//

TInt CLandmarkInterface::SapiError( TInt aSymbianErr )

    {

    TInt sapiErr(aSymbianErr);

    switch ( sapiErr )

        {

        //case EPosLmInvalidArgument:

        case KErrBadName:

        case KErrArgument:

            {

            sapiErr = SErrBadArgumentType;

            break;

            }

        case KErrNotSupported:

            {

            sapiErr = SErrServiceNotSupported;

            break;

            }

        case KErrLocked:

        case KErrInUse:

            {

            sapiErr = SErrServiceInUse;

            break;

            }

        case KErrAccessDenied:

            {

            sapiErr = SErrAccessDenied;

            break;

            }

        case KErrAlreadyExists:

            {

            sapiErr = SErrEntryExists;

            break;

            }

        case KErrNotReady:

            {

            sapiErr = SErrServiceNotReady;

            break;

            }

        case KErrNotFound:

            {

            sapiErr = SErrNotFound;

            break;

            }

        case KErrPosLmUnknownFormat:

            {

            sapiErr = SErrUnknownFormat;

            break;

            }

        case KErrPathNotFound:

            {

            sapiErr = SErrPathNotFound;

            break;

            }

        case KErrGeneral:

            {

            sapiErr = SErrGeneralError;

            break;

            }

        case SErrInvalidServiceArgument:

            break;

        case SErrMissingArgument:

            break;

        default:

            sapiErr = SErrGeneralError;

            break;

        }

    return sapiErr;

    }

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

// CLandmarkInterface::Close( )

// This function is called by the user to close the interface.

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

//

void CLandmarkInterface::Close( )

    {

    delete this;

    }

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

// CLandmarkInterface::Callback( TInt32 aTransactionId )

// This function returns the callback for the given transaction id and removes it from the list.

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

//

MLiwNotifyCallback* CLandmarkInterface::Callback( TInt32 aTransactionId )

    {

    MLiwNotifyCallback* callback=  NULL;

    TInt count = iCallbackMap.Count ( );

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

        {

        if ( iCallbackMap[i]->Get (aTransactionId, callback ) )

            {

            delete(iCallbackMap[i]);

            iCallbackMap.Remove (i );

            break;

            }

        }

    return callback;

    }

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

// CLandmarkInterface::SetActiveL( const CLiwGenericParamList& aInParamList )

// This calls the appropriate service function for setting active database.

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

//

void CLandmarkInterface::SetActiveL( const CLiwGenericParamList& aInParamList )

    {

    TInt index = 0;

    const TLiwGenericParam* database = aInParamList.FindFirst ( index, KDbUri );

    if ( !database )

        {

        // If position based parsing is implemented then

        // the name of parameter will be empty CHECK

        index = 0;

        database = aInParamList.FindFirst ( index, KNullDesC8 );

        }

    if ( database )

        {

        const TLiwVariant& variant = database->Value ( );

        if ( variant.TypeId ( )== LIW::EVariantTypeDesC )

            {

            iService->SetActiveL ( variant.AsDes ( ) );

            }

        else

            {

            User::Leave (SErrBadArgumentType );

            }

        }

    }

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

// CLandmarkInterface::SwitchCmdL( const TDesC8& aCmdName,

//                           const CLiwGenericParamList& aInParamList,

//                           CLiwGenericParamList& aOutParamList,

//                           TUint aCmdOptions,

//                           MLiwNotifyCallback* aCallback )

// This function calls the appropriate functions based on the command id.

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

//

void CLandmarkInterface::SwitchCmdL( const TDesC8& aCmdName,

        const CLiwGenericParamList& aInParamList,

        CLiwGenericParamList& aOutParamList, TUint aCmdOptions,

        MLiwNotifyCallback* aCallback )

    {

    if ( ( (KLiwOptASyncronous & aCmdOptions) && !aCallback) ||( !(KLiwOptASyncronous & aCmdOptions) && aCallback) )

        {

        iErrMsg = KIncorrectAsyncReq().AllocL ( );

        User::Leave (SErrInvalidServiceArgument );

        }

	if (!aCmdName.CompareF(KCancel) && (KLiwOptCancel & aCmdOptions))

		{

		Cancel(aInParamList, aOutParamList, aCmdOptions, aCallback);

		}

	else if (!aCmdName.CompareF(KGetList))

		{

		GetListL(aInParamList, aOutParamList, aCmdOptions, aCallback);

		}

	else if (!aCmdName.CompareF(KAdd))

		{

		AddL(aInParamList, aOutParamList, aCmdOptions, aCallback);

		}

	else if (!aCmdName.CompareF(KRemove))

		{

		RemoveL(aInParamList, aOutParamList, aCmdOptions, aCallback);

		}

	else if (!aCmdName.CompareF(KOrganise))

		{

		OrganiseL(aInParamList, aOutParamList, aCmdOptions, aCallback);

		}

	else if (!aCmdName.CompareF(KImport))

		{

		ImportL(aInParamList, aOutParamList, aCmdOptions, aCallback);

		}

	else if (!aCmdName.CompareF(KExport))

		{

		ExportL(aInParamList, aOutParamList, aCmdOptions, aCallback);

		}

	else

	//since no other APIs support async return error if callback is 

	//provide

	if (aCallback)

		{

		iErrMsg = KAsyncNotSupported().AllocL();

		User::Leave(SErrInvalidServiceArgument);

		}

	else if (!aCmdName.CompareF(KNew))

		{

		NewTemplateL(aInParamList, aOutParamList, aCmdOptions, aCallback);

		}

	else

		{

		// invalid command return error in outparam list

		iErrMsg = KInvalidServiceCmd().AllocL();

		User::Leave(SErrInvalidServiceArgument);

		}

	}

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

// CLandmarkInterface::GetListL(const CLiwGenericParamList& aInParamList,

//                           CLiwGenericParamList& aOutParamList,

//                           TUint aCmdOptions,

//                           MLiwNotifyCallback* aCallback )

// This function calls the appropriate functions based on the content type.

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

//

void CLandmarkInterface::GetListL( const CLiwGenericParamList& aInParamList,

        CLiwGenericParamList& aOutParamList, TUint aCmdOptions,

        MLiwNotifyCallback* aCallback )

    {

    //Input param List must have Type specified

    if ( !aInParamList.Count() )

        {

        ErrorMessageL (KGetList, KContentType );

        iErrMsg->Des().Append ( KMissing );

        //leave since argument is improper

        User::Leave (SErrMissingArgument );

        }

    //position to start search in input params

    TInt index = 0;

    //get content type

    const TLiwGenericParam* param = &aInParamList[EIndex0];

    //check whether pos based or value based

    if ( param->Name ( )!= KNullDesC8 )

        {

        param = aInParamList.FindFirst (index, KContentType );

        if ( !param )

            {

            ErrorMessageL (KGetList, KContentType );

            iErrMsg->Des().Append (KMissing );

            //leave since argument is improper

            User::Leave (SErrMissingArgument );

            }

        }

    TLiwVariant variant(param->Value ( ));

    ValidateParamL (KGetList, KContentType, variant, LIW::EVariantTypeDesC );

    TPtrC contentType(variant.AsDes ( ));

    //Content type is Landmark.

    if ( contentType == KLandmark )

        {

        GetLandmarksL (aInParamList, aOutParamList, aCmdOptions, aCallback );

        }

    //Content type is Category.

    else

        if ( contentType == KCategory )

            {

            GetCategoriesL (aInParamList, aOutParamList, aCmdOptions, aCallback );

            }

        //Content type is Database.

        else

            if ( contentType == KDatabase )

                {

                //Async not supported for databases

                if( !aCallback )

                	GetListDatabasesL (aInParamList, aOutParamList );

              	else

              		{

              		iErrMsg = KAsyncNotSupported().AllocL ( );

                	User::Leave (SErrInvalidServiceArgument );

              		}

                }

            else

                {

                ErrorMessageL (KGetList, KContentType );

                iErrMsg->Des().Append (KInvalid );

                //leave since argument is improper

                User::Leave (SErrInvalidServiceArgument );

                }

    }

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

// CLandmarkInterface::AddL(const CLiwGenericParamList& aInParamList,

//                           CLiwGenericParamList& aOutParamList,

//                           TUint /*aCmdOptions*/,

//                           MLiwNotifyCallback* /*aCallback*/ )

// This function calls the appropriate functions based on the content type.

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

//

void CLandmarkInterface::AddL(const CLiwGenericParamList& aInParamList,

		CLiwGenericParamList& aOutParamList, TUint aCmdOptions,

		MLiwNotifyCallback* aCallback)

    {

	//Input param List must have contentType and data specified

	if (aInParamList.Count() < EIndex2)

		{

		ErrorMessageL(KAdd, KArgsMissing);

		iErrMsg->Des().Append(KMissing);

		//leave since argument is improper

		User::Leave(SErrMissingArgument);

		}

    //position to start search in input params

    TInt index = 0;

    //get content type

    const TLiwGenericParam* param = &aInParamList[EIndex0];

    //check whether pos based or value based

    if ( param->Name ( )!= KNullDesC8 )

        {

        param = aInParamList.FindFirst (index, KContentType );

        if ( !param )

            {

            ErrorMessageL (KAdd, KContentType );

            iErrMsg->Des().Append (KMissing );

            //leave since argument is improper

            User::Leave (SErrMissingArgument );

            }

        }

    TLiwVariant variant(param->Value ( ));

    ValidateParamL (KAdd, KContentType, variant, LIW::EVariantTypeDesC );

    TPtrC contentType(variant.AsDes ( ));

	//Content type is Landmark

	if (contentType == KLandmark)

		{

		AddLandmarksL(aInParamList, aOutParamList, aCmdOptions, aCallback);

		}

	//Content type is Category.

	else if (contentType == KCategory)

		{

		AddCategoryL(aInParamList, aOutParamList, aCmdOptions, aCallback);

		}

	else

		{

		ErrorMessageL(KAdd, KContentType);

		iErrMsg->Des().Append(KInvalid);

		//leave since argument is improper

		User::Leave(SErrInvalidServiceArgument);

		}

	}

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

// CLandmarkInterface::RemoveL(const CLiwGenericParamList& aInParamList,

//                           CLiwGenericParamList& /*aOutParamList*/,

//                           TUint /*aCmdOptions*/,

//                           MLiwNotifyCallback* /*aCallback*/ )

// This calls the appropriate service function based on the content type.

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

//

void CLandmarkInterface::RemoveL(const CLiwGenericParamList& aInParamList,

		CLiwGenericParamList& aOutParamList, TUint /*aCmdOptions*/,

		MLiwNotifyCallback* aCallback)

	{

    //Input param List must have contentType and data specified

	if (aInParamList.Count() < EIndex2)

        {

        ErrorMessageL (KAdd, KArgsMissing );

        iErrMsg->Des().Append (KMissing );

        //leave since argument is improper

        User::Leave (SErrMissingArgument );

        }

    //position to start search in input params

    TInt index = 0;

    //Flag for pos based

    TBool posBased = EFalse;

    //get content type

    const TLiwGenericParam* param = &aInParamList[EIndex0];

    //check whether pos based or value based

    if ( param->Name ( )== KNullDesC8 )

        {

        posBased = ETrue;

        }

    else

        {

        param = aInParamList.FindFirst (index, KContentType );

        if ( !param )

            {

            ErrorMessageL (KRemove, KContentType );

            iErrMsg->Des().Append (KMissing );

            //leave since argument is improper

            User::Leave (SErrMissingArgument );

            }