/*

* Copyright (c) 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:  The implementation of LCD service

*

*/

#include <locodserviceplugin.h>

#include "locodservice.h"

#include "debug.h"

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

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

// Creates a service object based on the service plug in objects

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

//

CLocodService* CLocodService::NewL(CLocodServicePlugin& aPlugin)

    {

    CLocodService* self = new (ELeave) CLocodService(aPlugin);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// C++ destructor

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

//

CLocodService::~CLocodService()

    {

    delete iPlugin;

    iRequests.Close();

    TRACE_FUNC

    }

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

// return the plugin instance

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

//

CLocodServicePlugin& CLocodService::Plugin()

    {

    return *iPlugin;

    }

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

// A request is sent to service plug in to manage their services

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

//

TInt CLocodService::ManageService(TLocodBearer aBearer, TBool aStatus)

    {

    TRACE_INFO((_L("[Srvc %d] [SrvcState 0x%04x]"), iPlugin->ImplementationUid().iUid, iServiceStatus))

    // if there is an outstanding request which has the same bearer,

    // remove all later enqueued request, and

    // enqueue this request if the bearer status is different from the ongoing one.

    TInt count = iRequests.Count();

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

        {

        if (iRequests[i].iBearer == aBearer && iRequests[i].iRequesting)

            {

            for (TInt j = count - 1; j > i; j--)

                {

                if (iRequests[j].iBearer == aBearer)

                    {

                    TRACE_INFO((_L("[Srvc %d] [ManSrvc] Remove buffered request(Bearer 0x%04x status %d)"), 

                        iPlugin->ImplementationUid().iUid, aBearer, iRequests[j].iStatus))

                    iRequests.Remove(j);

                    }

                }

            if ((!iRequests[i].iStatus && aStatus) || (iRequests[i].iStatus && !aStatus))

                {

                TRACE_INFO((_L("[Srvc %d] [ManSrvc] Buffer request(Bearer 0x%04x status %d)"), 

                    iPlugin->ImplementationUid().iUid, aBearer, aStatus))

                return iRequests.Append(TLocodServiceRequest(aBearer, aStatus));

                }

            else

                {

                TRACE_INFO((_L("[Srvc %d] [ManSrvc] Request(Bearer 0x%04x status %d) discarded"), 

                    iPlugin->ImplementationUid().iUid, aBearer, aStatus))

                return KErrNone;

                }

            }

        }

    // else if the latest bearer status in this service plugin is different,

    // Start ManageService()

    if ( aStatus && !(iServiceStatus & aBearer) ||

        !aStatus && (iServiceStatus & aBearer))

        {

        TLocodServiceRequest request(aBearer, aStatus);

        request.iRequesting = ETrue;

        TInt err = iRequests.Append(request);

        TRACE_INFO((_L("[Srvc %d] [ManSrvc] Issue request(Bearer 0x%04x status %d)"), 

            iPlugin->ImplementationUid().iUid, aBearer, aStatus))

        if (!err)

            {

            iPlugin->ManageService(aBearer, aStatus);

            }

        return err;

        }

    // else the latest bearer status in this service plugin is the same,

    // do nothing

    TRACE_INFO((_L("[Srvc %d] [ManSrvc] Request(Bearer 0x%04x status %d) discarded"), 

        iPlugin->ImplementationUid().iUid, aBearer, aStatus))

    return KErrNone;

    }

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

// Based on the status of bearer either the request is removed or a new manage 

// service is issued

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

//

void CLocodService::ManageServiceCompleted(TLocodBearer aBearer, 

    TBool aStatus, TInt err)

    {

    TRACE_INFO((_L("[Srvc %d] [ManSrvc complete] (Bearer 0x%04x status %d) return %d"), 

        iPlugin->ImplementationUid().iUid, aBearer, aStatus, err))    

    // Save the latest status of this bearer

    if (!err)

        {

        if (aStatus)

            {

            iServiceStatus |= aBearer;

            }

        else

            {

            iServiceStatus &= (~aBearer);

            }

        TRACE_INFO((_L("[Srvc %d] [SrvcState 0x%04x]"), iPlugin->ImplementationUid().iUid, iServiceStatus))

        }

    // Find the completed request and remove it from the request list.

    TInt count = iRequests.Count();

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

        {

        if (iRequests[i].iBearer == aBearer && iRequests[i].iRequesting)

            {

            TRACE_INFO((_L("[Srvc %d] [ManSrvc completed] Remove completed request(Bearer 0x%04x status %d)"), 

                iPlugin->ImplementationUid().iUid, aBearer, iRequests[i].iStatus))            

            iRequests.Remove(i);

            break;

            }

        }

    // Find the next request and start ManageService if the status is changed.

    count = iRequests.Count();

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

        {

        if (iRequests[i].iBearer == aBearer)

            {

            if ( (iRequests[i].iStatus && !(iServiceStatus & aBearer)) ||

                 (!iRequests[i].iStatus && (iServiceStatus & aBearer)))

                {

                iRequests[i].iRequesting = ETrue;

                TRACE_INFO((_L("[Srvc %d] [ManSrvc completed] Issue buffered request(Bearer 0x%04x status %d)"), 

                    iPlugin->ImplementationUid().iUid, aBearer, iRequests[i].iStatus))

                iPlugin->ManageService(iRequests[i].iBearer, iRequests[i].iStatus);

                }

            else

                {

                TRACE_INFO((_L("[Srvc %d] [ManSrvc completed] Remove buffered request(Bearer 0x%04x status %d)"), 

                    iPlugin->ImplementationUid().iUid, aBearer, iRequests[i].iStatus))            

                iRequests.Remove(i);

                }

            break;

            }

        }

    }

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

// return if there are request pending

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

//

TBool CLocodService::HasServiceToManage() const

    {

    return iRequests.Count();

    }

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

// C++ default constructor

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

//

CLocodService::CLocodService(CLocodServicePlugin& aPlugin) : iPlugin(&aPlugin)

    {

    TRACE_FUNC_THIS

    }

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

// C++ 2nd phase construction

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

//

void CLocodService::ConstructL()

    {

    }

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

// C++ default constructor

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

//

TLocodServiceRequest::TLocodServiceRequest(TLocodBearer aBearer, TBool aStatus)

:   iBearer(aBearer), iStatus(aStatus), iRequesting(EFalse)

    {

    }