/*

* Copyright (c) 2005-2006 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:  CMnAiwCommandHandlerBase class implementation

*

*/

#include <AiwCommon.h>

#include <AiwCommon.hrh>

#include <AiwGenericParam.h>

#include <AiwGenericParam.hrh>

#include <EPos_Landmarks.h>

#include <EPos_CPosLandmark.h>

#include <epos_poslandmarkserialization.h>

#include <aknlistquerydialog.h>

#include <mnprovider.h>

#include <mnproviderfinder.h>

#include <mnappservices.hrh>

#include "mnaiwdebug.h"

#include "mnaiwinternal.h"

#include "mnaiwservices.h"

#include "mnshowonmaphandler.h"

#include "mnselectfrommaphandler.h"

#include "mnnavigatetohandler.h"

#include "mnfetchaddresshandler.h"

#include "mnfetchcoordinateshandler.h"

#include "mnaiwcommandhandlerbase.h"

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

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

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

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

//

CMnAiwCommandHandlerBase::CMnAiwCommandHandlerBase( CMnProvider& aProvider )

:   CActive( CActive::EPriorityStandard ),

    iProvider( aProvider )

    {

    CActiveScheduler::Add( this );

    }

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

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

//

CMnAiwCommandHandlerBase::~CMnAiwCommandHandlerBase()

    {

    }

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

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

//

void CMnAiwCommandHandlerBase::ConstructL()

    {

    }

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

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

//

void CMnAiwCommandHandlerBase::AppServiceAndFeatureNeeded(

    TInt aAiwServiceCommand, 

    CMnProvider::TService& aServiceNeeded,

    TInt& aFeaturesNeeded )

    {

    switch ( aAiwServiceCommand )

        {

        case KAiwCmdMnShowMap:

            aServiceNeeded = CMnProvider::EServiceMapView;

            aFeaturesNeeded = KMnSvcFeatureShowMap;

            break;

        case KAiwCmdMnSelectFromMap:

            aServiceNeeded = CMnProvider::EServiceMapView;

            aFeaturesNeeded = KMnSvcFeatureSelectFromMap;

            break;

        case KAiwCmdMnNavigateTo: 

            aServiceNeeded = CMnProvider::EServiceNavigation;

            aFeaturesNeeded = KMnSvcFeatureNavigateTo;

            break;

        case KAiwCmdMnCoordByAddr: 

            aServiceNeeded = CMnProvider::EServiceGeocoding;

            aFeaturesNeeded = KMnSvcFeatureAddrToCoord;

            break;

        case KAiwCmdMnAddrByCoord:         

            aServiceNeeded = CMnProvider::EServiceGeocoding;

            aFeaturesNeeded = KMnSvcFeatureCoordToAddr;

            break;

        default:            

            aServiceNeeded = CMnProvider::EServiceNone;

            aFeaturesNeeded = 0;

            break;

        }

    }

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

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

//

CMnAiwCommandHandlerBase::TRunMode CMnAiwCommandHandlerBase::DefaultRunMode( 

    TInt aAiwServiceCommand )

    {

    switch ( aAiwServiceCommand )

        {

        case KAiwCmdMnShowMap:

            return KShowOnMapChainedByDefault ? ERunModeChained : ERunModeStandalone;

        case KAiwCmdMnSelectFromMap:

            return KSelectFromMapChainedByDefault ? ERunModeChained : ERunModeStandalone;

        case KAiwCmdMnNavigateTo: 

            return KNavigateToChainedByDefault ? ERunModeChained : ERunModeStandalone;

        case KAiwCmdMnCoordByAddr: 

            return KFetchCoordinatesChainedByDefault ? ERunModeChained : ERunModeStandalone;

        case KAiwCmdMnAddrByCoord:         

            return KFetchAddressChainedByDefault ? ERunModeChained : ERunModeStandalone;

        default:            

            return ERunModeDefault;

        }

    }

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

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

//

CMnAiwCommandHandlerBase* CMnAiwCommandHandlerBase::CreateHandlerL( 

    TInt aAiwServiceCommand, 

    CMnProvider& aProvider,

    TRunMode aRunMode )

    {

    CMnAiwCommandHandlerBase* handler = NULL;

    switch ( aAiwServiceCommand )

        {

        case KAiwCmdMnShowMap:

            handler = CMnShowOnMapHandler::NewL( aProvider, aRunMode );

            break;

        case KAiwCmdMnNavigateTo:

            handler = CMnNavigateToHandler::NewL( aProvider, aRunMode );

            break;

        case KAiwCmdMnSelectFromMap:

            handler = CMnSelectFromMapHandler::NewL( aProvider, aRunMode );

            break;

        case KAiwCmdMnAddrByCoord:

            handler = CMnFetchAddressHandler::NewL( aProvider, aRunMode );

            break;

        case KAiwCmdMnCoordByAddr:

            handler = CMnFetchCoordinatesHandler::NewL( aProvider, aRunMode );

            break;

        default:

            User::Leave( KErrNotSupported );

            break;

        }

    return handler;

    }

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

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

//

void CMnAiwCommandHandlerBase::SetParametersL( const TAiwParameters& aAiwParameters )

    {

    __ASSERT_DEBUG( !IsActive(), Panic( KErrGeneral ) );

    iAiwParameters = aAiwParameters;

    ProcessAiwParametersL();

    }

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

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

//

void CMnAiwCommandHandlerBase::ResetParametersL()

    {

    }

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

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

//

void CMnAiwCommandHandlerBase::StartL()

    {

    DoStartL();

    }

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

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

//

void CMnAiwCommandHandlerBase::Start( MMnAsyncAiwCmdHandlerCallback& aCallback )

    {

    LOG("CMnAiwCommandHandlerBase::Start in");

    iCallback = &aCallback;

    __ASSERT_DEBUG( iCallback, Panic( KErrGeneral ) );

    TInt err = KErrNone;

    TRAP( err, DoStartL() );

    if ( err )

        {

        Done( err );

        }

    else

        {

        SetActive();

        }

    LOG("CMnAiwCommandHandlerBase::Start out");

    }

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

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

//

CMnAiwCommandHandlerBase::TAiwParameters& CMnAiwCommandHandlerBase::AiwParameters()

    {

    return iAiwParameters;

    }

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

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

//

CMnAiwCommandHandlerBase::TRunMode CMnAiwCommandHandlerBase::RunMode()

	{

	return iRunMode;

	}

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

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

//

void CMnAiwCommandHandlerBase::SetExitObserverL( 

	MMnProviderExitCallback& aExitCallback )

	{

	iExitCallback = &aExitCallback;

	}

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

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

//

CMnProvider& CMnAiwCommandHandlerBase::Provider()

    {

    return iProvider;

    }

// ================= INTERNAL FUNCTIONS =======================

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

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

//

void CMnAiwCommandHandlerBase::Done( TInt aResult )

    {

    TRAP_IGNORE( iCallback->HandleAsyncAiwCmdCompletedL( this, aResult ) );

    } 

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

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

//

void CMnAiwCommandHandlerBase::ProcessAiwParametersL()

    {

    LOG("CMnAiwCommandHandlerBase::ProcessAiwParametersL in");

    RArray<TPtrC8> lmBuffers;

    CleanupClosePushL( lmBuffers );

    TPtrC dbUri;

    RArray<TPosLmItemId> lmIds;

    CleanupClosePushL( lmIds );

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

        {

        const TAiwGenericParam& param = AiwParameters().InList()[i];

        switch ( param.SemanticId() )

            {

            case EGenericParamMnCommonOptions:

                //LOG("CMnAiwCommandHandlerBase::ProcessAiwParametersL, CommonOptions");

                // already handled

                break;

            case EGenericParamLandmark:

                //LOG("CMnAiwCommandHandlerBase::ProcessAiwParametersL, Landmark");

                {

                TPtrC8 lmData;

                ReadLandmarkDataL( param, lmData );

                lmBuffers.AppendL( lmData );

                break;

                }

            case EGenericParamLandmarkDatabase:

                //LOG("CMnAiwCommandHandlerBase::ProcessAiwParametersL, LandmarkDatabase");

                {

                if ( dbUri.Length() && lmIds.Count() )

                    {

                    HandleAiwParamLandmarksListL( dbUri, lmIds );

                    dbUri.Set( NULL, 0 );

                    lmIds.Reset();

                    }

                ReadDatabaseUriL( param, dbUri );

                break;

                }

            case EGenericParamLandmarkId:

                //LOG("CMnAiwCommandHandlerBase::ProcessAiwParametersL, LandmarkId");

                {

                if ( dbUri.Length() )

                    {

                    TPosLmItemId lmId = ReadLandmarkId( param );

                    lmIds.AppendL( lmId );

                    }

                else

                    {

                    User::Leave( KErrArgument );

                    }

                break;

                }

            case EGenericParamLandmarkIdList:

                //LOG("CMnAiwCommandHandlerBase::ProcessAiwParametersL, LandmarkIdList");

                {

                if ( dbUri.Length() )

                    {

                    TInt numLmIds = 0;

                    const TPosLmItemId* lmIdList = NULL;

                    ReadLandmarkIdListL( param, lmIdList, numLmIds );

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

                        {

                        lmIds.AppendL( *(lmIdList + i) );

                        }

                    }

                else

                    {

                    User::Leave( KErrArgument );

                    }

                break;

                }

            default:

                HandleAiwParamL( param );                

            }

        }

    if ( lmBuffers.Count() )

        {

        HandleAiwParamLandmarksL( lmBuffers );

        }

    if ( dbUri.Length() && lmIds.Count() )

        {

        HandleAiwParamLandmarksListL( dbUri, lmIds );

        }

    CleanupStack::PopAndDestroy( &lmIds );

    CleanupStack::PopAndDestroy( &lmBuffers );

    LOG("CMnAiwCommandHandlerBase::ProcessAiwParametersL out");

    }

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

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

//

CMnAiwCommandHandlerBase::TRunMode CMnAiwCommandHandlerBase::RequestedRunModeL( 

    const CMnAiwCommandHandlerBase::TAiwParameters& aAiwParams )

    {

    TMnAiwCommonOptionsParamExtended commonOptionsExtended;

    if ( FindCommonOptionsL( aAiwParams, commonOptionsExtended ) )

        {

        if ( commonOptionsExtended.iFieldsSet & EMnAiwCommonOptionsFieldRunChained )

            {

            return commonOptionsExtended.iRunChained ? ERunModeChained : ERunModeStandalone;

            }

        }

    return ERunModeDefault;

    }

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

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

//

TBool CMnAiwCommandHandlerBase::IsProviderSpecifiedL( 

    const CMnAiwCommandHandlerBase::TAiwParameters& aAiwParams,

    TInt& aProviderId )

    {

    TMnAiwCommonOptionsParamExtended commonOptionsExtended;

    if ( FindCommonOptionsL( aAiwParams, commonOptionsExtended ) )

        {

        if ( commonOptionsExtended.iFieldsSet & EMnAiwCommonOptionsFieldProviderId )

            {

            aProviderId = commonOptionsExtended.iProviderId;

            return ETrue;

            }

        }

    return EFalse;

    }

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

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

//

TBool CMnAiwCommandHandlerBase::IsErrorMessageDisabledL( 

    const CMnAiwCommandHandlerBase::TAiwParameters& aAiwParams )

    {

    TMnAiwCommonOptionsParamExtended commonOptionsExtended;

    if ( FindCommonOptionsL( aAiwParams, commonOptionsExtended ) )

        {

        if ( commonOptionsExtended.iFieldsSet & EMnAiwCommonOptionsFieldMessagesDisabled )

            {

            return commonOptionsExtended.iMessagesDisabled;

            }

        }

    return EFalse;

    }

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

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

//

TBool CMnAiwCommandHandlerBase::FindCommonOptionsL( 

    const TAiwParameters& aAiwParams,

    TMnAiwCommonOptionsParamExtended& aCommonOptions )

    {

    TInt indexOptions = 0;

    aAiwParams.InList().FindFirst( indexOptions, EGenericParamMnCommonOptions, EVariantTypeDesC8 );

    if ( indexOptions != KErrNotFound )

        {

        const TAiwVariant& value = aAiwParams.InList()[indexOptions].Value();

        TPtrC8 data( value.AsData() ); 

        if ( data.Size() == sizeof( TMnAiwCommonOptionsParamExtended ) )

            {

            TPckg<TMnAiwCommonOptionsParamExtended> optionsPack( aCommonOptions );

            optionsPack.Copy( data );

            return ETrue;

            }

        else if ( data.Size() == sizeof( TMnAiwCommonOptionsParam ) )

            {

            TMnAiwCommonOptionsParam commonOptions;

            TPckg<TMnAiwCommonOptionsParam> optionsPack( commonOptions );

            optionsPack.Copy( data );

            aCommonOptions.iFieldsSet = EMnAiwCommonOptionsFieldRunChained;

            aCommonOptions.iRunChained = commonOptions.iRunChained;

            return ETrue;

            }

        }

    return EFalse;        

    }

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

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

//

void CMnAiwCommandHandlerBase::ReadLandmarkDataL( const TAiwGenericParam& aParam, TPtrC8& aLandmarkPtr )

    {

    aLandmarkPtr.Set( aParam.Value().AsData() );

    // verify it

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

    delete lm;

    }

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

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

//

TBool CMnAiwCommandHandlerBase::FindLandmarkData( TInt aIndex, TAiwGenericParam& aParam )

    {

    TInt found = -1;

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

        {

        const TAiwGenericParam& param = AiwParameters().InList()[i];

        if ( param.SemanticId() == EGenericParamLandmark )

            {

            found++;

            }

        if ( found == aIndex )

            {

            aParam = param;

            return ETrue;

            }

        }

    return EFalse;        

    }

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

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

//

void CMnAiwCommandHandlerBase::ReadDatabaseUriL( const TAiwGenericParam& aParam, TPtrC& aDbUri )

    {

    aDbUri.Set( aParam.Value().AsDes() );

    if ( !aDbUri.Length() )

        {

        User::Leave( KErrArgument );

        }

    }

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

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

//

TPosLmItemId CMnAiwCommandHandlerBase::ReadLandmarkId( const TAiwGenericParam& aParam )

    {

    return aParam.Value().AsTInt32();

    }

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

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

//

void CMnAiwCommandHandlerBase::ReadLandmarkIdListL( 

    const TAiwGenericParam& aParam,

    const TPosLmItemId*& aListPtr,

    TInt& aListSize )

    {

    TPtrC8 data( aParam.Value().AsData() );

    if ( data.Size() % sizeof( TPosLmItemId ) )

        {

        User::Leave( KErrArgument );

        }

    aListPtr = reinterpret_cast<const TPosLmItemId*>( data.Ptr() );

    aListSize = data.Size() / sizeof( TPosLmItemId );

    }