/*

* Copyright (c) 2002-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: Forwards client request messages to server operations.

*

*

*/

#include <EPos_Landmarks.h>

#include "EPos_CPosLmServer.h"

#include "EPos_PosLmServerCommon.h"

#include "EPos_LmServerGlobal.h"

#include "EPos_CPosLmServerOperation.h"

#include "EPos_CPosLmInitializer.h"

#include "EPos_MPosLmServerManagerObserver.h"

#include "EPos_CPosLmOperationManager.h"

const TInt KArrayGranularity = 5;

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

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

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

//

CPosLmOperationManager::CPosLmOperationManager(

    CPosLmServer& aServer,

    TPosOperationManagerType aType,

    MPosLmServerManagerObserver* aObserver ) :

    CBase(),

    iServer( aServer ),

    iType( aType ),

    iObserver( aObserver )

    {

    }

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

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

//

void CPosLmOperationManager::ConstructL()

    {

    iUriArray = new (ELeave) CDesCArrayFlat(KArrayGranularity);

    }

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

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

//

CPosLmOperationManager* CPosLmOperationManager::NewL(

    CPosLmServer& aServer,

    TPosOperationManagerType aType,

    MPosLmServerManagerObserver* aObserver )

    {

    CPosLmOperationManager* self = new( ELeave ) CPosLmOperationManager(

        aServer, aType, aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

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

//

CPosLmOperationManager::~CPosLmOperationManager()

    {

    iOperations.ResetAndDestroy();

    iOperations.Close();

    delete iUriArray;

    }

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

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

//

void CPosLmOperationManager::HandleOperationStatus(

    CPosLmServerOperation* aServerOperation,

    TInt aStatus)

    {

    if ( aStatus != KPosLmOperationNotComplete &&

         aServerOperation && !aServerOperation->HasClients() )

        {

        // Remove operation

        TInt index = iOperations.Find(aServerOperation);

        if (index != KErrNotFound)

            {

            delete aServerOperation;

            aServerOperation = NULL;

            iOperations.Remove(index);

            iUriArray->Delete(index);

            }

        if (iOperations.Count() == 0)

            {

            iObserver->HandleManagerFinished();

            }

        }

    }

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

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

//

void CPosLmOperationManager::AddRequestL(

    const RMessage2& aMessage,

    const TDesC& aUri,

    TAny* aSession)

    {

    switch (aMessage.Function())

        {

        // Get operation corresponding to the URI and add the message to its

        // wait list.

        case EPosLmServerInitializeSync:

        case EPosLmServerLangSwitchSync:

        case EPosLmServerRecoverSync:

            OperationL( aUri, aSession )->AddToSyncWaitListL( aMessage, aSession );

            break;

        case EPosLmServerInitializeAsync:

        case EPosLmServerLangSwitchAsync:

        case EPosLmServerRecoverAsync:

            OperationL( aUri, aSession )->AddToAsyncWaitListL( aMessage, aSession );

            break;

        case EPosLmServerInitializeCancel:

        case EPosLmServerLangSwitchCancel:

        case EPosLmServerRecoverCancel:

            {

            CPosLmServerOperation* op = FindOperationL( aUri );

            if ( op )

                {

                op->RemoveFromAsyncWaitList( aMessage, aSession );

                }

            else

                {

                LmServerGlobal::Complete( aMessage, KErrNone );

                }

            break;

            }

        default:

            User::Leave(KErrNotSupported);

            break;

        }

    }

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

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

//

TInt CPosLmOperationManager::Count()

    {

    return iOperations.Count();

    }

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

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

//

void CPosLmOperationManager::RemoveSessionMessages(

    TAny* aSession)

    {

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

        {

        iOperations[i]->RemoveSessionMessages(aSession);

        }

    }

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

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

//

CPosLmServerOperation* CPosLmOperationManager::FindOperationL( const TDesC& aUri )

    {

    CPosLmServerOperation* operation = NULL;

    TInt position;

    if ( iUriArray->Find( aUri, position ) == 0 )

        {

        // Operation found at position.

        operation = iOperations[position];

        }

    return operation;

    }

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

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

//

CPosLmServerOperation* CPosLmOperationManager::CreateOperationL( const TDesC& aUri )

    {

    CPosLmServerOperation* operation = NULL;

    switch (iType)

        {

        case EPosInitializerManager:

            operation = CPosLmInitializer::NewL( iServer, this, aUri );

            break;

        default:

            User::Leave(KErrArgument);

            break;

        }

    CleanupStack::PushL(operation);

    // Append URI and operation to arrays.

    iUriArray->AppendL(aUri);

    TInt error = iOperations.Append(operation);

    if (error != KErrNone)

        {

        // Append of operation failed, delete last URI from URI array.

        // Both arrays should match.

        iUriArray->Delete(iUriArray->Count() - 1);

        User::Leave(error);

        }

    CleanupStack::Pop(operation);

    return operation;

    }

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

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

//

CPosLmServerOperation* CPosLmOperationManager::OperationL( 

    const TDesC& aUri,

    TAny* aSession )

    {

    CPosLmServerOperation* operation = FindOperationL( aUri );

    if ( operation )

        {

        if ( operation->Status() != KPosLmOperationNotComplete &&

            !operation->IsRegistered( aSession ) )

            {

            operation = NULL; // new operation for this client 

            }

        else

            {

            // this client has yet to get result of this operation

            }

        }

    if ( !operation )

        {

        // need new operation

        operation = CreateOperationL( aUri );

        }

    return operation;

    }