/*

* 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 "subcommands.h"

#include "msmmserver.h"

#include "msmmengine.h"

#include "msmmnodebase.h"

#include "handlerinterface.h"

#include "msmm_internal_def.h"

#include <usb/hostms/msmmpolicypluginbase.h>

#include <usb/hostms/srverr.h>

#include <usb/usblogger.h>

/**

 *  TRegisterInterface member functions

 */

TRegisterInterface::TRegisterInterface(THostMsSubCommandParam aParam):

TSubCommandBase(aParam),

iDeviceNode(NULL),

iInterfaceNode(NULL)

    {

    }

void TRegisterInterface::DoExecuteL()

    {

    // Add new interface node into data engine

    iInterfaceNode = iServer.Engine().AddUsbMsInterfaceL(iEvent.iDeviceId, 

            iEvent.iInterfaceNumber, iEvent.iInterfaceToken);

    iDeviceNode = iServer.Engine().SearchDevice(iEvent.iDeviceId);

    if (!iDeviceNode)

        {

        User::Leave(KErrArgument);

        }

    TUSBMSDeviceDescription& device = iDeviceNode->iDevice;

    iMsConfig.iInterfaceToken = iEvent.iInterfaceToken;

    iMsConfig.iInterfaceNumber = iEvent.iInterfaceNumber;        

    iMsConfig.iVendorId = device.iVendorId;

    iMsConfig.iProductId = device.iProductId;

    iMsConfig.iBcdDevice = device.iBcdDevice;

    iMsConfig.iConfigurationNumber = device.iConfigurationNumber;        

    iMsConfig.iSerialNumber.Copy(device.iSerialNumber);

    iMsConfig.iProtocolId = device.iProtocolId;

    iMsConfig.iTransportId = device.iTransportId;

    iMsConfig.iRemoteWakeup = device.iRemoteWakeup;

    iMsConfig.iIsOtgClient = device.iIsOtgClient;

    TSuspensionPolicy suspensionPolicy;

    iServer.PolicyPlugin()->GetSuspensionPolicy(suspensionPolicy);

    iMsConfig.iOtgSuspendTime = suspensionPolicy.iOtgSuspendTime;

    iMsConfig.iStatusPollingInterval = suspensionPolicy.iStatusPollingInterval;

    iHandler.Start();

    iInterfaceNode->iUsbMsDevice.Add(iMsConfig, iHandler.Status());

    }

void TRegisterInterface::HandleError(THostMsErrData& aData, TInt aError)

    {

    switch (aError)

        {

    case KErrNoMemory:

        aData.iError = EHostMsErrOutOfMemory;

        break;

    case KErrAlreadyExists:

    case KErrArgument:

        aData.iError = EHostMsErrInvalidParameter;

        break;

    default:

        aData.iError = EHostMsErrGeneral;

        }

    aData.iE32Error = aError;

    if (iDeviceNode)

        {

        TUSBMSDeviceDescription& device = iDeviceNode->iDevice;

        aData.iManufacturerString.Copy(device.iManufacturerString);

        aData.iProductString.Copy(device.iProductString);

        aData.iDriveName = 0x0;        

        }

    if (iInterfaceNode)

        {

        iServer.Engine().RemoveUsbMsNode(iInterfaceNode);

        iInterfaceNode = NULL;

        }

    }

void TRegisterInterface::DoAsyncCmdCompleteL()

    {

    User::LeaveIfError(iHandler.Status().Int());

    if(iInterfaceNode)

        {

        User::LeaveIfError(

                iInterfaceNode->iUsbMsDevice.GetNumLun(iMaxLogicalUnit));

        }

    iCreator.CreateSubCmdForRetrieveDriveLetterL(iMaxLogicalUnit);

    }

void TRegisterInterface::DoCancelAsyncCmd()

    {

    if(iInterfaceNode)

        {

        iInterfaceNode->iUsbMsDevice.Remove();

        iServer.Engine().RemoveUsbMsNode(iInterfaceNode);

        iInterfaceNode = NULL;

        }

    }

/**

 *  TRetrieveDriveLetter member functions

 */

TRetrieveDriveLetter::TRetrieveDriveLetter(

        THostMsSubCommandParam& aParameter, TInt aLuNumber):

TSubCommandBase(aParameter),

iLuNumber(aLuNumber),

iDrive(0)

    {

    }

void TRetrieveDriveLetter::DoExecuteL()

    {

    TUsbMsDevice* deviceEntry(NULL);

    deviceEntry = iServer.Engine().SearchDevice(iEvent.iDeviceId);

    if (!deviceEntry)

        {

        User::Leave(KErrArgument);

        }

    else

        {

        TUSBMSDeviceDescription& device = deviceEntry->iDevice;

        iRequestData.iBcdDevice = device.iBcdDevice;

        iRequestData.iConfigurationNumber = device.iConfigurationNumber;

        iRequestData.iInterfaceNumber = iEvent.iInterfaceNumber;

        iRequestData.iDeviceId = iEvent.iDeviceId;

        iRequestData.iProductId = device.iProductId;

        iRequestData.iVendorId = device.iVendorId;

        iRequestData.iLogicUnitNumber = iLuNumber;

        iRequestData.iOtgInformation = device.iOtgInformation;

        iRequestData.iManufacturerString = device.iManufacturerString;

        iRequestData.iProductString = device.iProductString;

        iRequestData.iSerialNumber = device.iSerialNumber;

        iHandler.Start();

        TRequestStatus& status = iHandler.Status();

        iServer.PolicyPlugin()->RetrieveDriveLetterL(

                iDrive, iRequestData, status);

        }

    }

void TRetrieveDriveLetter::HandleError(THostMsErrData& aData, TInt aError)

    {

    switch (aError)

        {

    case KErrArgument:

        aData.iError = EHostMsErrInvalidParameter;

        break;

    case KErrNotFound:

        aData.iError = EHostMsErrNoDriveLetter;

        break;

    case KErrNoMemory:

        aData.iError = EHostMsErrOutOfMemory;

        break;

    default:

        aData.iError = EHostMsErrGeneral;

        }

    aData.iE32Error = aError;

    aData.iManufacturerString = iRequestData.iManufacturerString;

    aData.iProductString = iRequestData.iProductString;

    aData.iDriveName = iDrive;

    }

void TRetrieveDriveLetter::DoAsyncCmdCompleteL()

    {

    User::LeaveIfError(iHandler.Status().Int());

    iCreator.CreateSubCmdForMountingLogicalUnitL(iDrive, iLuNumber);

    }

void TRetrieveDriveLetter::DoCancelAsyncCmd()

    {

    iServer.PolicyPlugin()->CancelRetrieveDriveLetter();

    }

/**

 *  TMountLogicalUnit member functions

 */

TMountLogicalUnit::TMountLogicalUnit(THostMsSubCommandParam& aParameter,

        TText aDrive, TInt aLuNumber):

TSubCommandBase(aParameter),

iDrive(aDrive),

iLuNumber(aLuNumber)

    {

    iIsKeyCommand = EFalse;

    }

void TMountLogicalUnit::DoExecuteL()

    {

    TInt ret(KErrNone);

    RFs& fs = iServer.FileServerSession();

    TInt driveNum;

    User::LeaveIfError(fs.CharToDrive(iDrive, driveNum));

    TUsbMsDevice* device = NULL;

    TUsbMsInterface* interface = NULL;

    device = iServer.Engine().SearchDevice(iEvent.iDeviceId);

    if (!device)

        {

        User::Leave(KErrArgument);

        }

    interface = iServer.Engine().SearchInterface(device, iEvent.iInterfaceNumber);

    if (!interface)

        {

        User::Leave(KErrArgument);

        }

    ret = interface->iUsbMsDevice.MountLun(iLuNumber, driveNum);

    if ((KErrNone != ret) && (KErrAlreadyExists != ret)

            && (KErrNotReady != ret))

        {

        }

    iHandler.Start();

    iHandler.Complete();

    }

void TMountLogicalUnit::HandleError(THostMsErrData& aData, TInt aError)

    {

    switch (aError)

        {

    case KErrNoMemory:

        aData.iError = EHostMsErrOutOfMemory;

        break;

    case KErrArgument:

        aData.iError = EHostMsErrInvalidParameter;

        break;

    case KErrCorrupt:

        {

        aData.iError = EHostMsErrUnknownFileSystem;

        // Current implementation of USB Mass Storage extension will mount

        // a logical unit successfully even the logical unit is in an 

        // unsupported format like NTFS or CDFS. So we have to recode this 

        // Logical unit down in the our data engine in order to dismount it

        // in future when the interface which presents this logical unit is

        // dettached. Reuse DoAsyncCmdCompleteL to do this.

        // Check if the new drive mounted successfully.

        RFs& fs = iServer.FileServerSession();

        TInt driveNum;

        User::LeaveIfError(fs.CharToDrive(iDrive, driveNum));

        TDriveList drives;

        User::LeaveIfError(fs.DriveList(drives));

        if (drives[driveNum])

            {

            // Drive name mounted

            DoAsyncCmdCompleteL();

            // Restart the handler

            iHandler.Start();

            }

        }

        break;

    default:

        aData.iError = EHostMsErrGeneral;

        }

    aData.iE32Error = aError;

    TUsbMsDevice* deviceNode = iServer.Engine().SearchDevice(iEvent.iDeviceId);

    if (deviceNode)

        {

        aData.iManufacturerString.Copy(deviceNode->iDevice.iManufacturerString);

        aData.iProductString.Copy(deviceNode->iDevice.iProductString);

        }

    aData.iDriveName = iDrive;

    }

void TMountLogicalUnit::DoAsyncCmdCompleteL()

    {

    iServer.Engine().AddUsbMsLogicalUnitL(

            iEvent.iDeviceId, iEvent.iInterfaceNumber, 

            iLuNumber, iDrive);

    iCreator.CreateSubCmdForSaveLatestMountInfoL(iDrive, iLuNumber);

    }

/**

 *  TSaveLatestMountInfo member functions

 */

TSaveLatestMountInfo::TSaveLatestMountInfo(

        THostMsSubCommandParam& aParameter,

        TText aDrive, TInt aLuNumber):

TSubCommandBase(aParameter),

iDrive(aDrive),

iLuNumber(aLuNumber)

    {

    iIsKeyCommand = EFalse;

    }

void TSaveLatestMountInfo::DoExecuteL()

    {

    TUsbMsDevice* deviceEntry(NULL);

    deviceEntry = iServer.Engine().SearchDevice(iEvent.iDeviceId);

    if (!deviceEntry)

        {

        User::Leave(KErrArgument);

        }

    else

        {

        TPolicyRequestData& request = iRecord.iLogicUnit;

        TUSBMSDeviceDescription& device = deviceEntry->iDevice;

        request.iBcdDevice = device.iBcdDevice;

        request.iConfigurationNumber = device.iConfigurationNumber;

        request.iInterfaceNumber = iEvent.iInterfaceNumber;

        request.iDeviceId = iEvent.iDeviceId;

        request.iProductId = device.iProductId;

        request.iVendorId = device.iVendorId;

        request.iLogicUnitNumber = iLuNumber;

        request.iOtgInformation = device.iOtgInformation;

        request.iManufacturerString = device.iManufacturerString;

        request.iProductString = device.iProductString;

        request.iSerialNumber = device.iSerialNumber;

        iRecord.iDriveName = iDrive;

        iHandler.Start();

        TRequestStatus& status = iHandler.Status();

        iServer.PolicyPlugin()->SaveLatestMountInfoL(iRecord, status);

        }

    }

void TSaveLatestMountInfo::DoAsyncCmdCompleteL()

    {

    User::LeaveIfError(iHandler.Status().Int());

    }

void TSaveLatestMountInfo::HandleError(THostMsErrData& aData, TInt aError)

    {

    switch (aError)

        {

    case KErrNoMemory:

        aData.iError = EHostMsErrOutOfMemory;

        break;

    case KErrArgument:

        aData.iError = EHostMsErrInvalidParameter;

        break;

    default:

        aData.iError = EHostMsErrGeneral;

        }

    aData.iE32Error = aError;

    aData.iManufacturerString = iRecord.iLogicUnit.iManufacturerString;

    aData.iProductString = iRecord.iLogicUnit.iProductString;

    aData.iDriveName = iDrive;

    }

void TSaveLatestMountInfo::DoCancelAsyncCmd()

    {

    iServer.PolicyPlugin()->CancelSaveLatestMountInfo();

    }

/**

 *  TDeregisterInterface member functions

 */

TDeregisterInterface::TDeregisterInterface(

        THostMsSubCommandParam& aParameter, 

        TUint8 aInterfaceNumber, TUint32 aInterfaceToken):

TSubCommandBase(aParameter),

iInterfaceNumber(aInterfaceNumber),

iInterfaceToken(aInterfaceToken),

iDeviceNode(NULL),

iInterfaceNode(NULL)

    {

    }

void TDeregisterInterface::DoExecuteL()

    {

    iDeviceNode = iServer.Engine().SearchDevice(iEvent.iDeviceId);

    if (!iDeviceNode)

        {

        User::Leave(KErrArgument);

        }

    iInterfaceNode = iServer.Engine().SearchInterface(iDeviceNode, 

            iInterfaceNumber);

    if (!iInterfaceNode)

        {

        User::Leave(KErrArgument);

        }

    TUSBMSDeviceDescription& device = iDeviceNode->iDevice;

    iMsConfig.iInterfaceToken = iInterfaceToken;

    iMsConfig.iVendorId = device.iVendorId;

    iMsConfig.iProductId = device.iVendorId;

    iMsConfig.iBcdDevice = device.iBcdDevice;

    iMsConfig.iConfigurationNumber = device.iConfigurationNumber;

    iMsConfig.iInterfaceNumber = iInterfaceNumber;

    iMsConfig.iSerialNumber.Copy(device.iSerialNumber);

    iInterfaceNode->iUsbMsDevice.Remove();

    // Activate the handler.

    iHandler.Start();

    // Simulate a async request be completed.

    iHandler.Complete();

    }

void TDeregisterInterface::HandleError(THostMsErrData& aData, TInt aError)

    {