/*

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

*

*/

#include <badesca.h>

#include <aknlistquerydialog.h>

#include <AknGlobalNote.h>

#include <AiwMenu.h>

#include <AiwGenericParam.hrh>

#include <AiwCommon.hrh>

#include <aknenv.h>

#include <ecom/implementationproxy.h>

#include <mnaiwproviderres.rsg>

#include "mnaiwprovideruids.hrh"

#include <lbsposition.h>

#include <mnprovider.h>

#include <mnproviderfinder.h>

#include <mnmapview.h>

#include <mnnavigator.h>

#include <mngeocoder.h>

#include <mnutils.h>

#include <mnappservices.hrh>

#include "mnaiwdebug.h"

#include "mnaiwinternal.h"

#include "mnaiwservices.h"

#include "mnaiwmenus.hrh"

#include "mnaiwprovider.h"

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

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

//  Cleanup item for RPointerArray<CMnProvider>

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

//

void CleanupProvidersArray( TAny* aArray )

    {

    ( static_cast<RPointerArray<CMnProvider>*>( aArray ) )->ResetAndDestroy();

    }

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

//  Identity relation for providers. Based on UID

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

//

TBool ProvidersMatchByUid( const CMnProvider& aOne, const CMnProvider& aAnother )

	{

	return ( aOne.Uid().iUid == aAnother.Uid().iUid );

	}

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

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

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

//

CMnAiwProvider* CMnAiwProvider::NewL()

    {

    LOG( "CMnAiwProvider::NewL in" );

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    LOG( "CMnAiwProvider::NewL out" );

    return self;

    }

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

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

//

CMnAiwProvider::CMnAiwProvider()

    {

    }

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

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

//

CMnAiwProvider::~CMnAiwProvider()

    {

    LOG( "~CMnAiwProvider in" );

    delete iEventList;

    CloseAllHandlers();

    iHandlers.Close();

    if ( iEikon )

        {

        iEikon->DeleteResourceFile( iResourceOffset );

        }

    iMnProviders.ResetAndDestroy();

    LOG( "~CMnAiwProvider out" );

    }

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

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

//

void CMnAiwProvider::ConstructL()

    {

    LOG( "CMnAiwProvider::ConstructL in" );

#ifdef _DEBUG

    TTime start;

    start.UniversalTime();

#endif

    iEikon = CEikonEnv::Static();

    TRAPD( err, MnUtils::FindLocalizedResourceFileL( iEikon->FsSession(), KAiwResourceFile, iResourceFilename ) );

    if ( err == KErrNotFound )

        {

        // try to find it with the name it had in 3.1

        // this is needed for the case, when upgrade is installed on 3.1-based terminals

        MnUtils::FindLocalizedResourceFileL( iEikon->FsSession(), KAiwResourceFileOld, iResourceFilename );

        }

    iResourceOffset = iEikon->AddResourceFileL( iResourceFilename );

    iEventList = CAiwGenericParamList::NewL();

#ifdef _DEBUG

    TTime finish;

    finish.UniversalTime();

    TTimeIntervalMicroSeconds elapsed = finish.MicroSecondsFrom( start );

    LOG1( "CMnAiwProvider::ConstructL out ( in %ld microseconds ) ", elapsed.Int64() );

#endif

    }

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

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

//

TInt CMnAiwProvider::GetAiwServiceCommandIdL( const CAiwGenericParamList& aInParamList )

    {

    TInt index = 0;

    const TAiwGenericParam* param = aInParamList.FindFirst( index, EGenericParamServiceCommand );

    if ( index < 0 )

        {

        LOG( "CMnAiwProvider::GetServiceCommandL: param not found" );

        User::Leave( KErrArgument );

        }

    TInt32 num = 0;

    const TAiwVariant& val = param->Value();

    if ( !val.Get( num ) )

        {

        LOG( "CMnAiwProvider::GetServiceCommandL: param value not found" );

        User::Leave( KErrArgument );

        }

    return num;

    }

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

// From CAiwServiceIfBase

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

//

void CMnAiwProvider::InitialiseL(

    MAiwNotifyCallback& /*aFrameworkCallback*/,

    const RCriteriaArray& /*aInterest*/ )

    {

    LOG("CMnAiwProvider::InitialiseL");

    }

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

// From CAiwServiceIfBase

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

//

void CMnAiwProvider::HandleServiceCmdL(

    const TInt& aCmdId,

    const CAiwGenericParamList& aInParamList,

    CAiwGenericParamList& aOutParamList,

    TUint aCmdOptions,

    const MAiwNotifyCallback* aCallback)

    {

    LOG1("CMnAiwProvider::HandleServiceCmdL cmdId: %x", aCmdId);

    if ( aCmdOptions & KAiwOptCancel )

        {

        // this is call to cancel async request,

        // not supported yet - ignoring, but not starting new one.

        LOG("CMnAiwProvider::HandleServiceCmdL attempt to cancel, exit");

        return;

        }

    CMnAiwCommandHandlerBase::TAiwParameters

        aiwParams( aInParamList, aOutParamList, aCallback );

    switch ( aCmdId )

        {

        case KAiwCmdMnShowMap:

        case KAiwCmdMnNavigateTo:

            {

            TInt err = KErrNone;

            TBool stop = EFalse;

            while ( !stop )

                {

                TRAP( err, ProcessSyncAiwCommandL( aCmdId, aiwParams ) );

                ProcessAiwCommandResultL( aCmdId, aiwParams, err, stop );

                }

            User::LeaveIfError( err );

            }

            break;

        case KAiwCmdMnSelectFromMap:

        case KAiwCmdMnCoordByAddr:

        case KAiwCmdMnAddrByCoord:

            if ( !aCallback )

                {

                User::Leave( KErrArgument );

                }

            StartAsyncAiwCommandL( aCmdId, aiwParams );

            break;

        default:

            User::Leave( KErrNotSupported );

            break;

        }

    }

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

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

//

void CMnAiwProvider::ProcessSyncAiwCommandL(

    TInt aCommandId,

    CMnAiwCommandHandlerBase::TAiwParameters& aAiwParams )

    {

    LOG("CMnAiwProvider::ProcessSyncAiwCommandL in");

	CMnAiwCommandHandlerBase* handler = HandlerL( aCommandId, aAiwParams );

    handler->StartL();

    LOG("CMnAiwProvider::ProcessSyncAiwCommandL out");

    }

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

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

//

void CMnAiwProvider::StartAsyncAiwCommandL(

    TInt aCommandId,

    CMnAiwCommandHandlerBase::TAiwParameters& aAiwParams )

    {

    LOG("CMnAiwProvider::StartAsyncAiwCommandL in");

    TBool stop = EFalse;

    while ( !stop )

        {

        TInt err = KErrNone;

        CMnAiwCommandHandlerBase* handler = NULL;

        TRAP( err, handler = HandlerL( aCommandId, aAiwParams ) );

        if ( !err )

            {

            handler->Start( *this );

            break;

            }

        else

            {

            if ( handler )

                {

                CloseHandler( handler );

                }

            if ( err == KErrCancel )

                {

                // must stop if provider selection fails

                stop = ETrue;

                }

            else

                {

                // this is error from command start

                ProcessAiwCommandResultL( aCommandId, aAiwParams, err, stop );

                }

            if ( stop )

                {

                // couldn't start command

                NotifyAiwObserver( aCommandId, aAiwParams, err );

                }

            }

        }

    LOG("CMnAiwProvider::StartAsyncAiwCommandL out");

    }

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

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

//

CMnAiwCommandHandlerBase* CMnAiwProvider::HandlerL(

    TInt aCommandId,

    CMnAiwCommandHandlerBase::TAiwParameters& aAiwParams )

    {

    LOG("CMnAiwProvider::HandlerL in");

    CMnProvider& provider = SelectProviderL( aCommandId, aAiwParams );

    CMnAiwCommandHandlerBase::TRunMode runMode =

        CMnAiwCommandHandlerBase::RequestedRunModeL( aAiwParams );

    if ( runMode == CMnAiwCommandHandlerBase::ERunModeDefault )

        {

        runMode = CMnAiwCommandHandlerBase::DefaultRunMode( aCommandId );

        }

    if ( runMode == CMnAiwCommandHandlerBase::ERunModeDefault )

        {

        User::Leave( KErrNotSupported );

        }

    CMnAiwCommandHandlerBase* handler = FindWorkingHandler( aCommandId, provider, runMode );

    if ( !handler )

        {

        handler = CMnAiwCommandHandlerBase::CreateHandlerL( aCommandId, provider, runMode );

        CleanupStack::PushL( handler );

        handler->SetExitObserverL( *this );

        iHandlers.AppendL( handler );

        CleanupStack::Pop( handler );

        }

    else

        {

        LOG("CMnAiwProvider::HandlerL, working handler found, reusing");

        handler->ResetParametersL();

        }

    handler->SetParametersL( aAiwParams );

    LOG("CMnAiwProvider::HandlerL out");

    return handler;

    }

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

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

//

void CMnAiwProvider::HandleAsyncAiwCmdCompletedL(

    CMnAiwCommandHandlerBase* aHandler,

    TInt aResult )

    {

    LOG1("CMnAiwProvider::HandleAsyncAiwCmdCompletedL in, result %d", aResult );

    TInt command = aHandler->CommandId();

    CMnAiwCommandHandlerBase::TAiwParameters aiwParams = aHandler->AiwParameters();

    CloseHandler( aHandler );

    TBool stop = EFalse;

    ProcessAiwCommandResultL( command, aiwParams, aResult, stop );

    if ( stop )

        {

        NotifyAiwObserver( command, aiwParams, aResult );

        }

    else

        {

        StartAsyncAiwCommandL( command, aiwParams );

        }

    LOG("CMnAiwProvider::HandleAsyncAiwCmdCompletedL out");

    }

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

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

//

void CMnAiwProvider::HandleProviderExit(

    CMnAiwCommandHandlerBase* aHandler )

    {

    LOG("CMnAiwProvider::HandleProviderExit in" );

	CloseHandler( aHandler );

    LOG("CMnAiwProvider::HandleProviderExit out");

    }

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

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

//

void CMnAiwProvider::NotifyAiwObserver(

    TInt aCommandId,

    CMnAiwCommandHandlerBase::TAiwParameters& aAiwParams,

    TInt aResult )

    {

    LOG2("CMnAiwProvider::NotifyAiwObserver in, command 0x%X, result %d", aCommandId, aResult);

    __ASSERT_DEBUG( aAiwParams.Callback(), Panic( KErrGeneral) );

    MAiwNotifyCallback* callback = const_cast<MAiwNotifyCallback*>( aAiwParams.Callback() );

    TInt err = KErrNone;

    iEventList->Reset();

    if ( aResult )

        {

        TAiwGenericParam error( EGenericParamError, TAiwVariant( aResult ) );

        TRAP_IGNORE( iEventList->AppendL( error ) );

        TRAP( err, callback->HandleNotifyL(

            aCommandId, KAiwEventError, *iEventList, aAiwParams.InList() ) );

        }

    else

        {

        TRAP( err, callback->HandleNotifyL(

            aCommandId, KAiwEventCompleted, *iEventList, aAiwParams.InList() ) );

        }

    LOG("CMnAiwProvider::NotifyAiwObserver out");

    }

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

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

//

void CMnAiwProvider::CloseHandler( CMnAiwCommandHandlerBase* aHandler )

    {

    LOG("CMnAiwProvider::CloseHandler in");

    if ( aHandler->IsActive() )

    	{

    	// make sure we are not panicked if async handler is closed while active.

    	// at first, command is only cancelled. Cancel will call this method again,

    	// then this object will be deleted.

    	aHandler->Cancel();

    	}

	TInt index = iHandlers.Find( aHandler );

	if ( index != KErrNotFound )

	    {

    	delete aHandler;

    	iHandlers.Remove( index );

	    }

    LOG1("CMnAiwProvider::CloseHandler out, deleted handler %d", index);

    }

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

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

//

void CMnAiwProvider::ProcessAiwCommandResultL( 

    TInt aAiwCommandId, 

    CMnAiwCommandHandlerBase::TAiwParameters& aAiwParams,

    TInt aResult, 

    TBool& aStop )

    {

    LOG1("CMnAiwProvider::ProcessAiwCommandResultL in, result %d", aResult);

    TBool banMessages = EFalse;

    if ( CMnAiwCommandHandlerBase::IsErrorMessageDisabledL( aAiwParams ) )

        {

        banMessages = ETrue;

        }

    TInt unusedProviderId( 0 );

    TInt messageId( 0 );

    if ( aResult == KErrNone || aResult == KErrCancel )

        {

        aStop = ETrue;

        }

    else if ( CMnAiwCommandHandlerBase::IsProviderSpecifiedL( aAiwParams, unusedProviderId ) ) 

        {

        aStop = ETrue;

        messageId = R_MN_ERROR_SERVICE_UNAVAILABLE;

        }

    else if ( NumSuitableProviders( aAiwCommandId ) < 2 )

        {

        aStop = ETrue;

        messageId = R_MN_ERROR_NO_PROVIDER;

        }

    else

        {

        aStop = EFalse;

        messageId = R_MN_ERROR_SERVICE_UNAVAILABLE;

        }

    if ( !banMessages && messageId )

        {

        ErrorNote( messageId );

        }

    LOG("CMnAiwProvider::ProcessAiwCommandResultL out");

    }

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

// From CAiwServiceIfMenu

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

//

void CMnAiwProvider::InitializeMenuPaneL(

    CAiwMenuPane& aMenuPane,

    TInt aIndex,

    TInt /*aCascadeId*/,

    const CAiwGenericParamList& aInParamList)

    {

    LOG( "CMnAiwProvider::InitializeMenuPaneL in" );

    TInt svcCmdId = GetAiwServiceCommandIdL( aInParamList );

    if ( !IsServiceAvailableL( svcCmdId ) )

        {

        LOG1( "CMnAiwProvider::InitializeMenuPaneL svc 0x%X is not available, out", svcCmdId );

        return;

        }

    switch ( svcCmdId )

        {

        case KAiwCmdMnShowMap:

            aMenuPane.AddMenuItemsL(

                iResourceFilename,

                R_MN_AIWMENU_SHOW_ON_MAP,

                KAiwCmdMnShowMap,

                aIndex);

            break;

        case KAiwCmdMnSelectFromMap:

            aMenuPane.AddMenuItemsL(