/*
* Copyright (c) 2010 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:
*
*/

#include <e32base.h>
#include <NormalHardcodedAssert.h>

#include <stubber.h>
#include <usbmandll_stub.h>
#include <usbpersonalityids.h>

#include "mockusbman.h"
#include "stifassertmacros.h"

#include "mockcusbvbusobserver.h"
#include "debug.h"

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

RUsb* RUsb::NewL()
    {
    LOG(  ( " MockRUsb::NewL" ) );
    RUsb* self = new ( ELeave ) RUsb();
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(); // pop self
    return self;
    }

void RUsb::ConstructL()
    {
    
    }

// ---------------------------------------------------------------------------
// From class MUsb
// ?implementation_description
// ---------------------------------------------------------------------------
//
RUsb::RUsb() : 
    iBusCleared(EFalse),
    iBusRequested(EFalse),
    iServiceStateNotificationRequested(EFalse),
    iTryStartError(KErrNone), 
    iBusRequestError(KErrNone),
    iCurrentPersonalityId(0),
    iUsbServiceState(EUsbServiceIdle)
    {
    LOG1 (" MockRUsb::RUsb: %d", iUsbServiceState );
    }

RUsb::~RUsb()
    {
    }

// ---------------------------------------------------------------------------
// From class MUsb
// ?implementation_description
// ---------------------------------------------------------------------------
//
void RUsb::TryStart(TInt aPersonalityId, TRequestStatus& aStatus)
    {
    LOG( (" MockRUsb::TryStart"));

//    CStubber* stubber = CStubber::NewL();
//    TApiBehavior beh( KUsbManStubAgentDll, ETryStartAsync, 0, 0, KNullDesC8 );
//    stubber -> InvokeApi( beh );
//
//    delete stubber;
//    stubber = NULL;
//    
//    if ( beh.iOutput != KNullDesC8 )
//        {            
        TRequestStatus* status = &aStatus;
        User::RequestComplete(status, iTryStartError);
//        }
    }

void RUsb::StartCancel(TRequestStatus& aStatus)
    {
    LOG( (" MockRUsb::StartCancel"));

    TRequestStatus* status = &aStatus;
    User::RequestComplete(status, iTryStartError);
    
    }

// ---------------------------------------------------------------------------
// From class MUsb
// ?implementation_description
// ---------------------------------------------------------------------------
//
void RUsb::TryStop(TRequestStatus& aStatus)
    {
    LOG( (" MockRUsb::TryStop"));
        
//    CStubber* stubber = CStubber::NewL();
//    TApiBehavior beh( KUsbManStubAgentDll, ETryStartAsync, 0, 0, KNullDesC8 );
//    stubber -> InvokeApi( beh );
//
//    delete stubber;
//    stubber = NULL;
//    
//    if ( beh.iOutput != KNullDesC8 )
//        {            
        TRequestStatus* status = &aStatus;
        User::RequestComplete(status, KErrNone);
//        }
    }

// ---------------------------------------------------------------------------
// From class MUsb
// ?implementation_description
// ---------------------------------------------------------------------------
//
void RUsb::MessageNotification(TRequestStatus& aStatus, TInt& aMessage)
    {
    LOG( (" MockRUsb::MessageNotification"));

    }

// ---------------------------------------------------------------------------
// From class MUsb
// ?implementation_description
// ---------------------------------------------------------------------------
//
void RUsb::MessageNotificationCancel()
    {
    LOG( (" MockRUsb::MessageNotificationCancel"));
    
    }

// ---------------------------------------------------------------------------
// From class MUsb
// ?implementation_description
// ---------------------------------------------------------------------------
//
void RUsb::HostEventNotification(TRequestStatus& aStatus,
        TDeviceEventInformation& aDeviceInformation)
    {
    LOG( (" MockRUsb::HostEventNotification"));

    }

// ---------------------------------------------------------------------------
// From class MUsb
// ?implementation_description
// ---------------------------------------------------------------------------
//
void RUsb::HostEventNotificationCancel()
    {
    LOG( (" MockRUsb::HostEventNotificationCancel"));
    
    }

// ---------------------------------------------------------------------------
// From class MUsb
// ?implementation_description
// ---------------------------------------------------------------------------
//
TInt RUsb::EnableFunctionDriverLoading()
    {
    LOG( (" MockRUsb::EnableFunctionDriverLoading"));

    return KErrNone;
    }

// ---------------------------------------------------------------------------
// From class MUsb
// ?implementation_description
// ---------------------------------------------------------------------------
//
void RUsb::DisableFunctionDriverLoading()
    {
    LOG( (" MockRUsb::DisableFunctionDriverLoading"));

    }

// ---------------------------------------------------------------------------
// From class MUsb
// ?implementation_description
// ---------------------------------------------------------------------------
//
TInt RUsb::BusRequest()
    {
    LOG1 (" MockRUsb::BusRequest, ret=%d", iBusRequestError );

    iBusRequested = ETrue;
    
    return iBusRequestError;
    }

// ---------------------------------------------------------------------------
// From class MUsb
// ?implementation_description
// ---------------------------------------------------------------------------
//
TInt RUsb::BusRespondSrp()
    {
    LOG( (" MockRUsb::BusRespondSrp"));
    
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// From class MUsb
// ?implementation_description
// ---------------------------------------------------------------------------
//
TInt RUsb::BusClearError()
    {
    LOG( (" MockRUsb::BusClearError"));
    iBusCleared = ETrue;

    return KErrNone;
    }

// ---------------------------------------------------------------------------
// From class MUsb
// ?implementation_description
// ---------------------------------------------------------------------------
//
TInt RUsb::BusDrop()
    {
    LOG( (" MockRUsb::BusDrop"));

    iBusRequested = EFalse;

    return KErrNone;
    }

// ---------------------------------------------------------------------------
// From class RSessionBase
// ?implementation_description
// ---------------------------------------------------------------------------
//
void RUsb::Close()
    {
    LOG( (" MockRUsb::Close"));

    }

void RUsb::SetTryStartError(TInt aError)
    {
    iTryStartError = aError;
    }

void RUsb::SetBusRequestError(TInt aError)
    {
    iBusRequestError = aError;
    }

void RUsb::SetUsbServiceState(TUsbServiceState aUsbServiceState)
    {
    LOG2 (" MockRUsb::SetUsbServiceState: %d, %d", iUsbServiceState, aUsbServiceState );
    iUsbServiceState = aUsbServiceState;
    }

TBool RUsb::GetVBusUp()
    {
    LOG2 (" MockRUsb::GetVBusUp, iBusRequested=%d, iBusRequestError=%d", iBusRequested , iBusRequestError);

    return iBusRequested && !iBusRequestError;
    }

TInt RUsb::GetServiceState(TUsbServiceState& aState)
    {
    LOG( (" MockRUsb::GetServiceState"));
    aState = iUsbServiceState;

    CStubber* stubber = CStubber::NewL();
    TApiBehavior beh( KUsbManStubAgentDll, EServiceState, 0, 0, KNullDesC8 );
    stubber -> InvokeApi( beh );

    delete stubber;
    stubber = NULL;
    
    if ( beh.iOutput != KNullDesC8 )
        {                        
        if ( !beh.iOutput.Compare( _L8( "EUsbServiceIdle" ) ) )
            aState = EUsbServiceIdle;
        else if ( !beh.iOutput.Compare( _L8( "EUsbServiceStarting" ) ) )
            aState = EUsbServiceStarting;
        else if ( !beh.iOutput.Compare( _L8( "EUsbServiceStarted" ) ) )
            aState = EUsbServiceStarted;
        else if ( !beh.iOutput.Compare( _L8( "EUsbServiceStopping" ) ) )
            aState = EUsbServiceStopping;
        else if ( !beh.iOutput.Compare( _L8( "EUsbServiceFatalError" ) ) )
            aState = EUsbServiceFatalError;
        }
    
    LOG1 (" iUsbServiceState: %d", aState);
    
    return KErrNone;
    }
    
void RUsb::ServiceStateNotification(TUsbServiceState &aState, TRequestStatus &aStatus)
{
	LOG( (" MockRUsb::ServiceStateNotification"));
	if(iServiceStateNotificationRequested)
	{
		TRequestStatus* status = &aStatus;
    User::RequestComplete(status, KErrGeneral);  // already requested
		return;
	}
	
	iServiceStateNotificationRequested = ETrue;
	TRequestStatus* status = &aStatus;
  User::RequestComplete(status, KErrNone); 
}
    
TInt RUsb::GetCurrentPersonalityId(TInt &aPersonalityId)
{
	LOG( (" MockRUsb::GetCurrentPersonalityId"));
	
	CStubber* stubber = CStubber::NewL();
	TApiBehavior beh( KUsbManStubAgentDll, EGetCurrentPersonalityId, 0, 0, KNullDesC8 );
	stubber -> InvokeApi( beh );

	delete stubber;
	stubber = NULL;
	
	if ( beh.iOutput != KNullDesC8 )
		{                        
		if ( !beh.iOutput.Compare( _L8( "UsbPersonalityIdPCSuite" ) ) )
			aPersonalityId = KUsbPersonalityIdPCSuite;
		else if ( !beh.iOutput.Compare( _L8( "UsbPersonalityIdMS" ) ) )
			aPersonalityId = KUsbPersonalityIdMS;
		else if ( !beh.iOutput.Compare( _L8( "UsbPersonalityIdPTP" ) ) )
			aPersonalityId = KUsbPersonalityIdPTP;
		else if ( !beh.iOutput.Compare( _L8( "UsbPersonalityIdMTP" ) ) )
			aPersonalityId = KUsbPersonalityIdMTP;
		else if ( !beh.iOutput.Compare( _L8( "UsbPersonalityIdPCSuiteMTP" ) ) )
			aPersonalityId = KUsbPersonalityIdPCSuiteMTP;

	    LOG1( " MockRUsb::GetCurrentPersonalityId iStubbedPersonalityId: %d", aPersonalityId);
		}
	else
		aPersonalityId = iCurrentPersonalityId;
	
	LOG1( " MockRUsb::GetCurrentPersonalityId iCurrentPersonalityId: %d", iCurrentPersonalityId);
	
	return KErrNone;
}
    
TInt RUsb::CancelInterest(TUsbReqType aMessageId) // to pending op. of usb service state
{
	LOG( (" MockRUsb::CancelInterest"));
	iServiceStateNotificationRequested = EFalse;
	return KErrNone;
}
    
void RUsb::ServiceStateNotificationCancel()
{
	LOG( (" MockRUsb::ServiceStateNotificationCancel"));
	iServiceStateNotificationRequested = EFalse;
}
    
void RUsb::SetCurrentPersonality(TInt aPersonalityId)
{
	LOG( (" MockRUsb::SetCurrentPersonality"));
	iCurrentPersonalityId = aPersonalityId;
}

TInt RUsb::GetOtgDescriptor(TUint aDeviceId, TOtgDescriptor& aDescriptor)
{
	LOG( (" MockRUsb::GetOtgDescriptor"));
	
	aDescriptor.iAttributes = 1;
	aDescriptor.iDeviceId = 2;
	
	return KErrNone;
}

// End of File