/*

* 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 == KCancel && (KLiwOptCancel & aCmdOptions) )

        {

        Cancel (aInParamList, aOutParamList, aCmdOptions, aCallback );

        }

    else

        if ( aCmdName == KGetList )

            {

            GetListL (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 == KAdd )

                    {

                    AddL (aInParamList, aOutParamList, aCmdOptions, aCallback );

                    }

                else

                    if ( aCmdName == KRemove )

                        {

                        RemoveL (aInParamList, aOutParamList, aCmdOptions,

                                aCallback );

                        }

                    else

                        if ( aCmdName == KOrganise )

                            {

                            OrganiseL (aInParamList, aOutParamList,

                                    aCmdOptions, aCallback );

                            }

                        else

                            if ( aCmdName == KImport )

                                {

                                ImportL (aInParamList, aOutParamList,

                                        aCmdOptions, aCallback );

                                }

                            else

                                if ( aCmdName == KExport )

                                    {

                                    ExportL (aInParamList, aOutParamList,

                                            aCmdOptions, aCallback );

                                    }

                                else

                                    if ( aCmdName == 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 );

        }

    //Content type is Category.

    else

        if ( contentType == KCategory )

            {

            AddCategoryL (aInParamList,aOutParamList );

            }

        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 );