/*
* 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 <e32debug.h>
#include "dpsstate.h"
#include "dpsstatemachine.h"
#include "dpstransaction.h"
#include "dpsscriptreceiver.h"
#include <pictbridge.h>
 
#ifdef _DEBUG
#	define IF_DEBUG(t) {RDebug::t;}
#else
#	define IF_DEBUG(t)
#endif
  
// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
TDpsIdleState::TDpsIdleState(CDpsStateMachine* aStateMachine) :
    iStateMachine(aStateMachine) {}
    
// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void TDpsIdleState::ScriptSentNotifyL(TBool /*aReply*/)
    {
    IF_DEBUG(Print(_L("TDpsIdleState::ScriptSentNotify")));
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void TDpsIdleState::ScriptReceivedNotifyL(TBool aReply)
    {
    if (!aReply)
        {
        IF_DEBUG(Print(_L("TDpsIdleState::ScriptReceived request got")));            
        iStateMachine->Trader()->ParseScriptL(aReply);    
        iStateMachine->SetState(iStateMachine->SendingRepState());
        }
    else
        {
        IF_DEBUG(Print(_L(
            "TDpsIdleState::ScriptReceived should not get reply!!!")));    
        }
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void TDpsIdleState::Error(TInt aErr)
    {
    IF_DEBUG(Print(_L("TDpsIdleState::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)
        {
        IF_DEBUG(Print(_L("TDpsSendingReqState::ScriptSent request")));
        iStateMachine->SetState(iStateMachine->WaitingRepState());
        }
    else
        {
        IF_DEBUG(Print(_L(
            "TDpsSendingReqState::ScriptSent should not get reply!!")));
        }
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void TDpsSendingReqState::ScriptReceivedNotifyL(TBool /*aReply*/)
    {
    IF_DEBUG(Print(_L("TDpsSendingReqState::ScriptReceived")));
    IF_DEBUG(Print(_L("**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*/)
    {    
    IF_DEBUG(Print(_L("TDpsWaitingRepState::ScriptSent")));
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void TDpsWaitingRepState::ScriptReceivedNotifyL(TBool aReply)
    {
    if (aReply)
        {
        IF_DEBUG(Print(_L("WaitingRepState reply")))
        
        iStateMachine->Trader()->ParseScriptL(aReply);      
        User::RequestComplete(
            iStateMachine->DpsEngine()->OperationRequest(), KErrNone);        
        iStateMachine->Initialize();        
        }
    else
        {
        IF_DEBUG(Print(_L("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)
        {
        IF_DEBUG(Print(_L("TDpsSendingRepState::ScriptSent 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
        {
        IF_DEBUG(Print(_L(
            "TDpsSendingRepState::ScriptSent shoul not get request!!!")));
        }
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void TDpsSendingRepState::ScriptReceivedNotifyL(TBool /*aReply*/)
    {
    IF_DEBUG(Print(_L("TDpsSendingRepState::ScriptReceived")));
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void TDpsSendingRepState::Error(TInt /*aErr*/)
    {
    return;
    }