/*

* Copyright (c) 2006, 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:  These classes implement dps states. 

*

*/

#include "dpsstate.h"

#include "dpsstatemachine.h"

#include "dpstransaction.h"

#include "dpsscriptreceiver.h"

#include <pictbridge.h>

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "dpsstateTraces.h"

#endif

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

// 

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

//

TDpsIdleState::TDpsIdleState(CDpsStateMachine* aStateMachine) :

    iStateMachine(aStateMachine) {}

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

// 

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

//

void TDpsIdleState::ScriptSentNotifyL(TBool /*aReply*/)

    {

    OstTraceFunctionEntry0( TDPSIDLESTATE_SCRIPTSENTNOTIFYL_ENTRY );

    OstTraceFunctionExit0( TDPSIDLESTATE_SCRIPTSENTNOTIFYL_EXIT );

    }

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

// 

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

//

void TDpsIdleState::ScriptReceivedNotifyL(TBool aReply)

    {

    if (!aReply)

        {

        OstTrace0( TRACE_NORMAL, TDPSIDLESTATE_SCRIPTRECEIVEDNOTIFYL, "request got" );

        iStateMachine->Trader()->ParseScriptL(aReply);    

        iStateMachine->SetState(iStateMachine->SendingRepState());

        }

    else

        {

        OstTrace0( TRACE_NORMAL, DUP1_TDPSIDLESTATE_SCRIPTRECEIVEDNOTIFYL, "should not get reply!!!" );

        }

    }

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

// 

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

//

void TDpsIdleState::Error(TInt aErr)

    {

    OstTrace1( TRACE_NORMAL, TDPSIDLESTATE_ERROR, "Error %d", aErr );

    if ((aErr != KErrCancel) && (aErr != KErrNotReady))

        {

        iStateMachine->Trader()->HandleHostRequestError(aErr);

        iStateMachine->SetState(iStateMachine->SendingRepState());    

        }

    }

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

// 

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

//

TDpsSendingReqState::TDpsSendingReqState(CDpsStateMachine* aStateMachine) :

    iStateMachine(aStateMachine) {}

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

// 

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

//

void TDpsSendingReqState::ScriptSentNotifyL(TBool aReply)

    {

    if (!aReply)

        {

        OstTrace0( TRACE_NORMAL, TDPSSENDINGREQSTATE_SCRIPTSENTNOTIFYL, " request" );

        iStateMachine->SetState(iStateMachine->WaitingRepState());

        }

    else

        {

        OstTrace0( TRACE_NORMAL, DUP1_TDPSSENDINGREQSTATE_SCRIPTSENTNOTIFYL, " should not get reply!!" );

        }

    }

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

// 

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

//

void TDpsSendingReqState::ScriptReceivedNotifyL(TBool /*aReply*/)

    {

    OstTrace0( TRACE_NORMAL, TDPSSENDINGREQSTATE_SCRIPTRECEIVEDNOTIFYL, "**should not reply to the request/reply from host" );

    }

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

// 

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

//

void TDpsSendingReqState::Error(TInt aErr)

    {

    User::RequestComplete(iStateMachine->DpsEngine()->OperationRequest(), 

                          aErr);

    iStateMachine->Initialize();                          

    return;

    }

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

// 

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

//

TDpsWaitingRepState::TDpsWaitingRepState(CDpsStateMachine* aStateMachine) :

    iStateMachine(aStateMachine) {}

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

// 

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

//

void TDpsWaitingRepState::ScriptSentNotifyL(TBool /*aReply*/)

    {    

    OstTraceFunctionEntry0( TDPSWAITINGREPSTATE_SCRIPTSENTNOTIFYL_ENTRY );

    OstTraceFunctionExit0( TDPSWAITINGREPSTATE_SCRIPTSENTNOTIFYL_EXIT );

    }

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

// 

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

//

void TDpsWaitingRepState::ScriptReceivedNotifyL(TBool aReply)

    {

    if (aReply)

        {

        OstTrace0( TRACE_NORMAL, TDPSWAITINGREPSTATE_SCRIPTRECEIVEDNOTIFYL, "WaitingRepState reply" );

        iStateMachine->Trader()->ParseScriptL(aReply);      

        User::RequestComplete(

            iStateMachine->DpsEngine()->OperationRequest(), KErrNone);        

        iStateMachine->Initialize();        

        }

    else

        {

        OstTrace0( TRACE_NORMAL, DUP1_TDPSWAITINGREPSTATE_SCRIPTRECEIVEDNOTIFYL, "WaitingRepState should not get request" );

        // collision happened, we do nothing because the host will

        // eventually handle this by sending the correct response. but we need

        // to subscribe for the event again.

        iStateMachine->ScriptReceiver()->WaitForReceive();

        }

    }

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

// 

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

//

void TDpsWaitingRepState::Error(TInt aErr)

    {

    // this is not tested

    User::RequestComplete(iStateMachine->DpsEngine()->OperationRequest(), 

                          aErr);

    iStateMachine->Initialize();                          

    }

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

// 

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

//

TDpsSendingRepState::TDpsSendingRepState(CDpsStateMachine* aStateMachine) :

    iStateMachine(aStateMachine) {}

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

// 

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

//

void TDpsSendingRepState::ScriptSentNotifyL(TBool aReply)

    {

    if (aReply)

        {

        OstTrace0( TRACE_NORMAL, TDPSSENDINGREPSTATE_SCRIPTSENTNOTIFYL, "reply" );

        if (KErrNone == iStateMachine->CurError())

            {

            // this is the normal situation, inform the client

            User::RequestComplete(iStateMachine->DpsEngine()->EventRequest(), 

                              KErrNone);    

            }

        else

            {

            // this is the error situation, do not inform the client. and

            // we need to subscribe for the new event.

            iStateMachine->ScriptReceiver()->WaitForReceive();

            }

        iStateMachine->Initialize();

        }

    else

        {

        OstTrace0( TRACE_NORMAL, DUP1_TDPSSENDINGREPSTATE_SCRIPTSENTNOTIFYL, "shoul not get request!!!" );

        }

    }

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

// 

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

//

void TDpsSendingRepState::ScriptReceivedNotifyL(TBool /*aReply*/)

    {

    OstTraceFunctionEntry0( TDPSSENDINGREPSTATE_SCRIPTRECEIVEDNOTIFYL_ENTRY );

    OstTraceFunctionExit0( TDPSSENDINGREPSTATE_SCRIPTRECEIVEDNOTIFYL_EXIT );

    }

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

// 

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

//

void TDpsSendingRepState::Error(TInt /*aErr*/)

    {

    return;

    }