/*

* 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:

*

*/

/**

 @file

 @internalComponent

*/

#include "eventhandler.h"

#include <usb/hostms/srverr.h>

#include <usb/usblogger.h>

#include "msmmserver.h"

#include "msmmengine.h"

#include "subcommands.h"

#include "msmmnodebase.h"

// Push a sub-command into the queue and transfer the owership 

// to the queue

void RSubCommandQueue::PushL(TSubCommandBase* aCommand)

    {

    CleanupStack::PushL(aCommand);

    iQueue.AppendL(aCommand);

    CleanupStack::Pop(aCommand);

    }

// Pop the head entity from the queue and destroy it

void RSubCommandQueue::Pop()

    {

    if (iQueue.Count() == 0)

        {

        return;

        }

    TSubCommandBase* command = iQueue[0];

    iQueue.Remove(0);

    delete command;

    command = NULL;

    }

// Insert a sub-command sequence after head entities

void RSubCommandQueue::InsertAfterHeadL(TSubCommandBase* aCommand)

    {

    if (!aCommand)

        {

        User::Leave(KErrArgument);

        }

    iQueue.InsertL(aCommand, 1);

    }

// Execute the head sub-comment

void RSubCommandQueue::ExecuteHeadL()

    {

    Head().ExecuteL();

    }

// Get a reference of head sub-command in queue

TSubCommandBase& RSubCommandQueue::Head()

    {

    return *iQueue[0];

    }

// Destory all entities and release the memory of queue

void RSubCommandQueue::Release()

    {

    iQueue.ResetAndDestroy();

    }

/*

 *  Public member functions

 */

CDeviceEventHandler::~CDeviceEventHandler()

    {

    Cancel();

    delete iErrNotiData;

    iSubCommandQueue.Release();

    }

CDeviceEventHandler* CDeviceEventHandler::NewL(MMsmmSrvProxy& aServer)

    {

    CDeviceEventHandler* self = CDeviceEventHandler::NewLC(aServer);

    CleanupStack::Pop(self);

    return self;

    }

CDeviceEventHandler* CDeviceEventHandler::NewLC(MMsmmSrvProxy& aServer)

    {

    CDeviceEventHandler* self = 

        new (ELeave) CDeviceEventHandler(aServer);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

void CDeviceEventHandler::CreateSubCmdForRetrieveDriveLetterL(

        TInt aLogicalUnitCount)

    {

    TRetrieveDriveLetter* command(NULL);

    THostMsSubCommandParam parameter(iServer, *this, *this, iIncomingEvent);

    for (TInt index = 0; index < aLogicalUnitCount; index++)

        {

        command = new (ELeave) TRetrieveDriveLetter(parameter, index);

        iSubCommandQueue.PushL(command);

        }

    }

void CDeviceEventHandler::CreateSubCmdForMountingLogicalUnitL(TText aDrive, 

        TInt aLuNumber)

    {

    THostMsSubCommandParam parameter(iServer, *this, *this, iIncomingEvent);

    TMountLogicalUnit* command = new (ELeave) TMountLogicalUnit(

            parameter, aDrive, aLuNumber);

    iSubCommandQueue.InsertAfterHeadL(command);

    }

void CDeviceEventHandler::CreateSubCmdForSaveLatestMountInfoL(TText aDrive, 

        TInt aLuNumber)

    {

    THostMsSubCommandParam parameter(iServer, *this, *this, iIncomingEvent);

    TSaveLatestMountInfo* command = 

        new (ELeave) TSaveLatestMountInfo(parameter, aDrive, aLuNumber);

    iSubCommandQueue.InsertAfterHeadL(command);

    }

void CDeviceEventHandler::Start()

    {

    if (IsActive())

        {

        return;

        }

    iStatus = KRequestPending;

    SetActive();

    }

void CDeviceEventHandler::Complete(TInt aError)

    {

    TRequestStatus* status = &iStatus;

    User::RequestComplete(status, aError);

    }

TRequestStatus& CDeviceEventHandler::Status() const

    {

    const TRequestStatus& status = iStatus;

    return const_cast<TRequestStatus&>(status);

    }

void CDeviceEventHandler::HandleEventL(TRequestStatus& aStatus, 

        const TDeviceEvent& aEvent)

    {

    if (IsActive())

        {

        // An event is being handled. Currently handler is busy.

        User::Leave(KErrInUse);

        }

    // Copy incoming event

    iIncomingEvent = aEvent;

    // Create sub-commands and append them to queue

    CreateSubCmdForDeviceEventL();

    aStatus = KRequestPending;

    iEvtQueueStatus = &aStatus;

    // Start the handler to handle the incoming event

    Start();

    Complete();

    }

/*

 * Protected member functions 

 */

void CDeviceEventHandler::DoCancel()

    {

    // Complete client with KErrCancel

    CompleteClient(KErrCancel);

    // Cancel current pending command

        {

    }

void CDeviceEventHandler::RunL( )

    {

    if (iSubCommandQueue.Count() == 0)

        {

        // Error occurs in lastest sub-command's DoExecuteL()

        // Or current command has been cancelled.

        return;

        }

    if (iSubCommandQueue.Head().IsExecuted())

        {

        // Complete the current sub-command

        iSubCommandQueue.Head().AsyncCmdCompleteL();

        iSubCommandQueue.Pop();

        }

    // Move to the next sub-command

    if (iSubCommandQueue.Count())

        {

        iSubCommandQueue.ExecuteHeadL();

        }

    else

        {

        // Run out of sub-commands. Current handling event achieved.

        // Complete client

        CompleteClient();

        }

    }

TInt CDeviceEventHandler::RunError(TInt aError)

    {

        {

        }

    if( IsActive() )

        {

        Complete(aError);

        }

    else if (iSubCommandQueue.Count())

        {

        Start();

   	    Complete();

        }

    return KErrNone;

    }

// Private member functions

CDeviceEventHandler::CDeviceEventHandler(MMsmmSrvProxy& aServer):

    CActive(EPriorityStandard),

    iServer(aServer)

    {

    CActiveScheduler::Add(this);

    }

void CDeviceEventHandler::ConstructL()

    {

    iErrNotiData = new (ELeave) THostMsErrData;

    ResetHandler();

    }

void CDeviceEventHandler::CreateSubCmdForDeviceEventL()

    {

    switch (iIncomingEvent.iEvent)

        {

    case EDeviceEventAddFunction:

        CreateSubCmdForAddingUsbMsFunctionL();

        break;

    case EDeviceEventRemoveDevice:

        CreateSubCmdForRemovingUsbMsDeviceL();

        break;

        }

    }

void CDeviceEventHandler::CreateSubCmdForAddingUsbMsFunctionL()

    {

    THostMsSubCommandParam parameter(iServer, *this, *this, iIncomingEvent);

    TRegisterInterface* command = new (ELeave) TRegisterInterface(parameter);

    iSubCommandQueue.PushL(command);

    }

void CDeviceEventHandler::CreateSubCmdForRemovingUsbMsDeviceL()

    {

    CMsmmEngine& engine = iServer.Engine();

    TUsbMsDevice* device = engine.SearchDevice(iIncomingEvent.iDeviceId);

    if (!device)

        {

        User::Leave(KErrNotFound);

        }

    TUsbMsInterface* interface = device->FirstChild();

    THostMsSubCommandParam parameter(iServer, *this, *this, iIncomingEvent);

    while (interface)

        {

        TUsbMsLogicalUnit* logicalUnit = interface->FirstChild();

        while (logicalUnit)

            {

            TDismountLogicalUnit* dismount = 

                new (ELeave) TDismountLogicalUnit(parameter, *logicalUnit);

            iSubCommandQueue.PushL(dismount);

            logicalUnit = logicalUnit->NextPeer();

            }

        TDeregisterInterface* deregister = new (ELeave) TDeregisterInterface(

                parameter, 

                interface->iInterfaceNumber, interface->iInterfaceToken);

        iSubCommandQueue.PushL(deregister);

        interface = interface->NextPeer();

        };

    TRemoveUsbMsDeviceNode* removeNode = 

        new (ELeave) TRemoveUsbMsDeviceNode(parameter, device);

    iSubCommandQueue.PushL(removeNode);

    }

void CDeviceEventHandler::ResetHandler()

    {

    ResetHandlerData();

    ResetHandlerError();

    }

void CDeviceEventHandler::ResetHandlerData()

    {

    // Reset event buffer

    iIncomingEvent.iDeviceId = 0;

    iIncomingEvent.iEvent = EDeviceEventEndMark;

    iIncomingEvent.iInterfaceNumber = 0;

    // Destory sub-command queue

    iSubCommandQueue.Release();

    }

void CDeviceEventHandler::ResetHandlerError()

    {

    // Reset error notification data

    iErrNotiData->iDriveName = 0x0;

    iErrNotiData->iError = EHostMsErrorEndMarker;

    iErrNotiData->iE32Error = KErrNone;

    iErrNotiData->iManufacturerString.Zero();

    }

void CDeviceEventHandler::CompleteClient(TInt aError/* = KErrNone*/)

    {

    if (iEvtQueueStatus)

        {

        User::RequestComplete(iEvtQueueStatus, aError);

        }

    }

// End of file