/*
* Copyright (c) 2006 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:    Simple Engine request
*
*/




// INCLUDE FILES

#include <e32std.h>

// own simple
#include "simplesipconnection.h"
#include "simplecommon.h"
#include "simpleenginerequest.h"
#include "msimpleenginerequest.h"
#include "msimpleowncallback.h"

#ifdef _DEBUG
#include "simpledebugutils.h"
#endif


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

// ----------------------------------------------------------
// CSimpleEngineRequest::CSimpleEngineRequest
// ----------------------------------------------------------
//
CSimpleEngineRequest::CSimpleEngineRequest(
    MSimpleOwnCallback& aEngine,
    MSimpleEngineRequest::TSimpleRequest aType,
    TInt aOpId )
: CActive( CActive::EPriorityHigh ), iType( aType ),
  iOpId( aOpId ), iEngine( aEngine ), iRefresh( ETrue ),
  iAux(0), iDestroyedPtr( NULL )
    {
    CActiveScheduler::Add(this);
    }

// ----------------------------------------------------------
// CSimpleEngineRequest::~CSimpleEngineRequest
// ----------------------------------------------------------
//
CSimpleEngineRequest::~CSimpleEngineRequest()
    {
#ifdef _DEBUG
    TSimpleLogger::Log(_L("EngineRequest: destructor ereq=%d" ), (TInt)this);
#endif

    if ( iDestroyedPtr )
        {
        // We are called inside callback
        *iDestroyedPtr = ETrue;
        iDestroyedPtr = NULL;
        }
        
    Cancel();
    delete iResponseData;   
    delete iRemoteURI;
    delete iRequestContentType;
    delete iResponseContentType;
    delete iResponseBoundary;
    delete iResponseStart;
    delete iETag;
    delete iRecipientId;
    }

// -----------------------------------------------------------------------------
// CSimpleEngineRequest::Destroy
// -----------------------------------------------------------------------------
void CSimpleEngineRequest::Destroy()
    {
#ifdef _DEBUG
    TSimpleLogger::Log(_L("EngineRequest: Destroy ereq=%d" ), (TInt)this);
#endif
    iLink.Deque();
    delete this;
    }

// ----------------------------------------------------------
// CSimpleEngineRequest::NewL
// ----------------------------------------------------------
//
CSimpleEngineRequest* CSimpleEngineRequest::NewL(
    MSimpleOwnCallback& aEngine,
    TSimpleRequest aType,
    TInt aOpId )
    {
    CSimpleEngineRequest* self = new (ELeave) CSimpleEngineRequest( aEngine, aType, aOpId );
#ifdef _DEBUG
    TSimpleLogger::Log(_L("EngineRequest: NewL ereq=%d" ), (TInt)self);
#endif
    return self;
    }

// ----------------------------------------------------------
// CSimpleEngineRequest::SetRequestData
// ----------------------------------------------------------
//
void CSimpleEngineRequest::SetRequestData( TPtrC8 aData )
    {
    iRequestData.Set(aData);
    }

// ----------------------------------------------------------
// CSimpleEngineRequest::SetRefreshTime
// ----------------------------------------------------------
//
void CSimpleEngineRequest::SetRefreshTime( TUint aTime )
    {
#ifdef _DEBUG
    TSimpleLogger::Log(_L("EngineRequest: SetRefreshTime %d" ), aTime);
#endif
    iRefreshTime = aTime;
    }

// ----------------------------------------------------------
// CSimpleEngineRequest::SetRemoteURIL
// ----------------------------------------------------------
//
void CSimpleEngineRequest::SetRemoteURIL( const TDesC8& aURI )
    {
    delete iRemoteURI;
    iRemoteURI = NULL;
    iRemoteURI = aURI.AllocL();
    }

// ----------------------------------------------------------
// CSimpleEngineRequest::RequestType
// ----------------------------------------------------------
//
MSimpleEngineRequest::TSimpleRequest CSimpleEngineRequest::RequestType()
    {
    return iType;
    }

// ----------------------------------------------------------
// CSimpleEngineRequest::ModifyType
// ----------------------------------------------------------
//
void CSimpleEngineRequest::ModifyType( MSimpleEngineRequest::TSimpleRequest aType )
    {
    iType = aType;
    }

// ----------------------------------------------------------
// CSimpleEngineRequest::Complete
// ----------------------------------------------------------
//
void CSimpleEngineRequest::Complete( TInt aStatus )
    {
#ifdef _DEBUG
    TSimpleLogger::Log(_L("EngineRequest: COMPLETE ereq=%d aStatus=%d" ),
        (TInt)this, aStatus );
#endif
   // Yield to scheduler in order to "break" a call stack before
   // continuing response handling.

    // RunL will handle the response further
    iStatus = KRequestPending;
    SetActive();
    TRequestStatus* s = &iStatus;
    User::RequestComplete( s, aStatus );
    }

// ----------------------------------------------------------
// CSimpleEngineRequest::RequestContentType
// ----------------------------------------------------------
//
TPtrC8 CSimpleEngineRequest::RequestContentType()
    {
    return iRequestContentType ? iRequestContentType->Des() : TPtrC8();
    }
    
// ----------------------------------------------------------
// CSimpleEngineRequest::SetRequestContentTypeL
// ----------------------------------------------------------
//
void CSimpleEngineRequest::SetRequestContentTypeL( const TDesC8& aData )
    {
    delete iRequestContentType;
    iRequestContentType = NULL;
    iRequestContentType = aData.AllocL(); 
    }    

// ----------------------------------------------------------
// CSimpleEngineRequest::RequestData
// ----------------------------------------------------------
//
TPtrC8 CSimpleEngineRequest::RequestData()
    {
    return iRequestData;
    }

// ----------------------------------------------------------
// CSimpleEngineRequest::SetResponseContentType(
// ----------------------------------------------------------
//
void CSimpleEngineRequest::SetResponseContentType( HBufC8* aData )
    {
    delete iResponseContentType;
    iResponseContentType = NULL;
    iResponseContentType = aData;
    }

// ----------------------------------------------------------
// CSimpleEngineRequest::SetResponseContentType(
// ----------------------------------------------------------
//
void CSimpleEngineRequest::SetResponseBoundaryL( const TDesC8& aData )
    {
    delete iResponseBoundary;
    iResponseBoundary = NULL;
    iResponseBoundary = aData.AllocL();
    }

// ----------------------------------------------------------
// CSimpleEngineRequest::SetResponseContentType(
// ----------------------------------------------------------
//
void CSimpleEngineRequest::SetResponseStartL( const TDesC8& aData )
    {
    delete iResponseStart;
    iResponseStart = NULL;
    iResponseStart = aData.AllocL();
    }

// ----------------------------------------------------------
// CSimpleEngineRequest::SetResponseDataL
// ----------------------------------------------------------
//
void CSimpleEngineRequest::SetResponseDataL( const TDesC8& aData )
    {
    delete iResponseData;
    iResponseData = NULL;
    iResponseData = aData.AllocL();
    }

// ----------------------------------------------------------
// CSimpleEngineRequest::SetRecipientL
// ----------------------------------------------------------
//
void CSimpleEngineRequest::SetRecipientL( const TDesC8& aRecipientId )
    {
    delete iRecipientId;
    iRecipientId = NULL;
    iRecipientId = aRecipientId.AllocL();
    }

// ----------------------------------------------------------
// CSimpleEngineRequest::SetResponseMethod
// ----------------------------------------------------------
//
void CSimpleEngineRequest::SetResponseMethod( TSimpleSIPResponse aMethod )
    {
    iResponseMethod = aMethod;
    }

// ----------------------------------------------------------
// CSimpleEngineRequest::ResponseMethod
// ----------------------------------------------------------
//
MSimpleEngineRequest::TSimpleSIPResponse CSimpleEngineRequest::ResponseMethod( )
    {
    return iResponseMethod;
    }

// ----------------------------------------------------------
// CSimpleEngineRequest::ResponseContentType
// ----------------------------------------------------------
//
TPtrC8 CSimpleEngineRequest::ResponseContentType()
    {
    return iResponseContentType ? iResponseContentType->Des() : TPtrC8();
    }

// ----------------------------------------------------------
// CSimpleEngineRequest::ResponseBoundary
// ----------------------------------------------------------
//
TPtrC8 CSimpleEngineRequest::ResponseBoundary()
    {
    return iResponseBoundary? iResponseBoundary->Des() : TPtrC8();
    }

// ----------------------------------------------------------
// CSimpleEngineRequest::ResponseStart
// ----------------------------------------------------------
//
TPtrC8 CSimpleEngineRequest::ResponseStart()
    {
    return iResponseStart ? iResponseStart->Des() : TPtrC8();
    }

// ----------------------------------------------------------
// CSimpleEngineRequest::ResponseData
// ----------------------------------------------------------
//
TPtrC8 CSimpleEngineRequest::ResponseData()
    {
    return iResponseData ? iResponseData->Des() : TPtrC8();
    }

// ----------------------------------------------------------
// CSimpleEngineRequest::Recipient
// ----------------------------------------------------------
//
TPtrC8 CSimpleEngineRequest::Recipient()
    {
    return iRecipientId ? iRecipientId->Des() : TPtrC8();
    }

// ----------------------------------------------------------
// CSimpleEngineRequest::RefreshTime
// ----------------------------------------------------------
//
TUint CSimpleEngineRequest::RefreshTime()
    {
    return iRefreshTime;
    }

// ----------------------------------------------------------
// CSimpleEngineRequest::RemoteURI
// ----------------------------------------------------------
//
TPtrC8 CSimpleEngineRequest::RemoteURI()
    {
    return iRemoteURI ? iRemoteURI->Des() : TPtrC8();
    }

// ----------------------------------------------------------
// CSimpleEngineRequest::IsRefresh
// ----------------------------------------------------------
//
TBool CSimpleEngineRequest::IsRefresh()
    {
    return iRefresh;
    }

// ----------------------------------------------------------
// CSimpleEngineRequest::SetRefresh
// ----------------------------------------------------------
//
void CSimpleEngineRequest::SetRefresh( TBool aRefresh )
    {
    iRefresh = aRefresh;
    }

// ----------------------------------------------------------
// CSimpleEngineRequest::OpId
// ----------------------------------------------------------
//
TInt CSimpleEngineRequest::OpId( )
    {
    return iOpId;
    }

// ----------------------------------------------------------
// CSimpleEngineRequest::Aux
// ----------------------------------------------------------
//
TInt CSimpleEngineRequest::Aux( )
    {
    return iAux;
    }

// ----------------------------------------------------------
// CSimpleEngineRequest::SetAux
// ----------------------------------------------------------
//
void CSimpleEngineRequest::SetAux( TInt aData )
    {
    iAux = aData;
    }

// ----------------------------------------------------------
// CSimpleEngineRequest::SetResponseReason
// ----------------------------------------------------------
void CSimpleEngineRequest::SetResponseReason( TSimpleResponseReason aReason )
    {
    iReason = aReason;
    }

// ----------------------------------------------------------
// CSimpleEngineRequest::ResponseReason
// ----------------------------------------------------------
MSimpleEngineRequest::TSimpleResponseReason CSimpleEngineRequest::ResponseReason()
    {
    return iReason;
    }
    
// -----------------------------------------------------------------------------
// CSimpleEngineRequest::SetETagL
// -----------------------------------------------------------------------------
void CSimpleEngineRequest::SetETagL( const TDesC8& aTag )
    {
    delete iETag;
    iETag = NULL;
    iETag = aTag.AllocL();
    }

// -----------------------------------------------------------------------------
// CSimpleEngineRequest::ETag
// -----------------------------------------------------------------------------
TPtrC8 CSimpleEngineRequest::ETag()
    {
    return iETag ? iETag->Des() : TPtrC8();    
    }

// -----------------------------------------------------------------------------
// CSimpleEngineRequest::RunL
// -----------------------------------------------------------------------------
//
void CSimpleEngineRequest::RunL()
    {
    TInt stat = iStatus.Int();
#ifdef _DEBUG
    TSimpleLogger::Log(_L("EngineRequest: RunL type=%d status=%d ereq=%d"),iType,stat, (TInt)this );
#endif

    // Set the member to point to stack variable
    TBool   destroyed( EFalse );
    iDestroyedPtr = &destroyed;

    // Call client callback method(s)
    iEngine.Complete( iOpId, stat, *this );
    
    // Check whether this entity is destroyed in Complete method.
    if ( destroyed )
        {
        return;
        }
                    
    // Reset response data
    delete iResponseData;
    iResponseData = NULL;
    delete iResponseContentType;
    iResponseContentType = NULL;
    delete iResponseBoundary;
    iResponseBoundary = NULL;
    delete iResponseStart;
    iResponseStart = NULL;
    delete iRecipientId;
    iRecipientId = NULL;
    iResponseMethod = EUnknownResponse;
    iReason = ENoReason;    
    
    iDestroyedPtr = NULL;    
    }

// ----------------------------------------------------------
// CSimpleEngineRequest::DoCancel
// ----------------------------------------------------------
//
void CSimpleEngineRequest::DoCancel()
    {
#ifdef _DEBUG
    TSimpleLogger::Log(_L("EngineRequest: DoCancel ereq=%d" ), (TInt)this );
#endif
    }