/*

* Copyright (c) 2004 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

*     This file contains the declaration of the Download Mgr Server.

*

*/

// INCLUDE FILES

#include "DownloadMgrLogger.h"

#include "DownloadMgrServer.h"

#include "DownloadMgrDef.h"

#include "DownloadMgrDefAttrib.h"

#include <e32svr.h>

#include <basched.h>

//#include <e32uid.h>

// CONSTANTS

// GLOBAL FUNCTIONS

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

// CDownloadSubSession::NewL

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

//

CDownloadSubSession * CDownloadSubSession::NewL( CDownloadMgrSession* aSession,

                                           CHttpDownload* aDownload )

	{

    CLOG_ENTERFN_NULL( "CDownloadSubSession::NewL" )

	CDownloadSubSession* self = new (ELeave) CDownloadSubSession();

	CleanupStack::PushL( self );

	self->ConstructL( aSession, aDownload );

	CleanupStack::Pop( self ); // self

	return self;

	}

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

// CDownloadSubSession::CDownloadSubSession

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

//

CDownloadSubSession::CDownloadSubSession()

:iEvent( EFalse )

    {

    CLOG_CREATE;

    }

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

// CDownloadSubSession::ConstructL

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

//

void CDownloadSubSession::ConstructL( CDownloadMgrSession *aSession,

                                   CHttpDownload* aDownload )

	{

    CLOG_ENTERFN( "CDownloadSubSession::ConstructL" )

	iSession = aSession;

    iDownload = aDownload;

#ifdef _DEBUG

    TInt32 dlId;

    aDownload->GetIntAttributeL( EDlAttrId, dlId );

    CLOG_NAME_2( _L("Download_%d_%d"), aSession->SessionId(), dlId );

#endif

	}

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

// CDownloadSubSession::~CDownloadSubSession

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

//

CDownloadSubSession::~CDownloadSubSession()

    {

    CLOG_WRITE( "CDownloadSubSession::~CDownloadSubSession()" )

    // Trigger the event queue

    TUint dummy( 0 );

    if( iSession )

        {

        iSession->Event( NULL, (THttpDownloadState)dummy, (THttpProgressState)dummy, (TInt32)dummy );

        }

    if( iAttribs )

        {

        iAttribs->ResetAndDestroy();

        delete iAttribs;

        iAttribs = NULL;

        }    

    CLOG_CLOSE;

    }

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

// CDownloadSubSession::CloseCounter

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

//

void CDownloadSubSession::CloseDownload()

	{

    CLOG_WRITE( "CDownloadSubSession::CloseDownload" )

    iDownload->DetachClientInstance(iSession->ClientAppInstance());

    iSession->ClientAppInstance()->ClientApp()->UnregisterDownload( iDownload ); 

	iSession->DeleteDownload( Message().Int3() );

	}

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

// CDownloadSubSession::Message

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

//

const RMessage2& CDownloadSubSession::Message() const

	{

    CLOG_WRITE( "CDownloadSubSession::Message()" );

    CLOG_WRITE_FORMAT( "iSession = %x", iSession );

	return iSession->CurrentMessage();

	}

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

// CDownloadSubSession::DispatchDownloadMessageL

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

//

void CDownloadSubSession::DispatchMessageL( const RMessage2& aMessage )

    {

    CLOG_ENTERFN( "CDownloadSubSession::DispatchMessageL" )

	switch( aMessage.Function() )

        {

        case EHttpDownloadStart:

            {

            StartL();

            return;

            }

        case EHttpDownloadEventSubscription:

            {

            InitDownloadEvent( aMessage );

            // Send event from the queue

            TUint dummy( 0 );

            iSession->Event( NULL, (THttpDownloadState)dummy, (THttpProgressState)dummy, (TInt32)dummy );

            // This is an asyncron request will be completed later!

            iSession->SetComplete( EFalse );

            return;

            }

        case EHttpDownloadEventCancel:

            {

            CancelDownloadEvent();

            return;

            }

        case EHttpDownloadPause:

            {

            PauseL();

            return;

            }

        case EHttpDownloadReset:

            {

            Reset();

            return;

            }

        case EHttpDownloadDelete:

            {

            Delete();

            return;

            }

        case EHttpDownloadMove:

            {

            MoveL();

            return;

            }

        case EHttpDownloadClose:

            {

            CloseDownload();

            return;

            }

        case EHttpDownloadCloseCompleted:

            {

            CloseCompletedDownload();

            return;

            }

        case EHttpDownloadGetIntAttribute:

            {

            GetIntAttributeL();

            return;

            }

        case EHttpDownloadGetBoolAttribute:

            {

            GetBoolAttributeL();

            return;

            }

        case EHttpDownloadGetStringAttribute:

            {

            GetStringAttributeL();

            return;

            }

        case EHttpDownloadGetString8Attribute:

            {

            GetString8AttributeL();

            return;

            }

        case EHttpDownloadSetIntAttribute:

            {

            SetIntAttributeL();

            return;

            }

        case EHttpDownloadSetBoolAttribute:

            {

            SetBoolAttributeL();

            return;

            }

        case EHttpDownloadSetStringAttribute:

            {

            SetStringAttributeL();

            return;

            }

        case EHttpDownloadSetString8Attribute:

            {

            SetString8AttributeL();

            return;

            }

        case EHttpDownloadBufferAttributes:

            {

            BufferAttributesL();

            return;

            }

        case EHttpDownloadGetRFile:

            {

            GetFileHandleAttributeL();

            return;

            }

        case EHttpDownloadSetRFile:

            {

            SetFileHandleAttributeL();

            return;

            }

        case EHttpDownloadDataAttribute:

            {

            SetDownloadDataAttributeL();

            return;

            }

        case EHttpDownloadTrackAttribute:

        	{

        	SetTrackDataAttributeL();

        	return;

        	}

        case EHttpDownloadSetOnError:

            {

            const TInt error = Message().Int0();

            const THttpDownloadMgrError dlerror 

                = (THttpDownloadMgrError)Message().Int1();

            OnError( error, dlerror );

            return;

            }

    	default:

            {

	    	iSession->PanicClient( EBadRequest );

            return;

            }

        }

    }

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

// CDownloadSubSession::Start

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

//

void CDownloadSubSession::StartL()

    {

    CLOG_ENTERFN( "CDownloadSubSession::StartL" )

    iDownload->StartL();

    }

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

// CDownloadSubSession::Attributes

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

//

void CDownloadSubSession::PauseL()

    {

    CLOG_ENTERFN( "CDownloadSubSession::PauseL" )

    iDownload->PauseL( ETrue );

    }

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

// CDownloadSubSession::Reset

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

//

void CDownloadSubSession::Reset()

    {

    CLOG_ENTERFN( "CDownloadSubSession::Reset" )

    iDownload->Reset();

    }

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

// CDownloadSubSession::Delete

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

//

void CDownloadSubSession::Delete()

    {

    CLOG_ENTERFN( "CDownloadSubSession::Delete()" )

    iSession->RemoveFromQueue( iDownload );

    iDownload->Delete( iSession->ClientAppInstance() );

    }

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

// CDownloadSubSession::CloseCompletedDownload

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

//

void CDownloadSubSession::CloseCompletedDownload()

	{

    CLOG_WRITE( "CDownloadSubSession::CloseCompletedDownload" )

    iDownload->DeleteInfoFile( iSession->ClientAppInstance() );

    iSession->RemoveFromQueue( iDownload );

    iSession->DeleteDownload( Message().Int3() );

	}

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

// CDownloadSubSession::MoveL

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

//

void CDownloadSubSession::MoveL()

    {

    CLOG_ENTERFN( "CDownloadSubSession::MoveL" )

    iDownload->MoveL();

    }

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

// CDownloadSubSession::InitDownloadEvent

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

//

void CDownloadSubSession::InitDownloadEvent( const RMessage2& aMessage )

    {

    CLOG_ENTERFN( "CDownloadSubSession::InitDownloadEvent" )

    __ASSERT_DEBUG( iEvent == EFalse, iSession->PanicClient( EMultipleInitDownloadEvent ) );

    iMessage = aMessage;

    iEvent = ETrue;

    }

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

// CDownloadSubSession::CancelDownloadEvent

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

//

void CDownloadSubSession::CancelDownloadEvent()

    {

    CLOG_ENTERFN( "CDownloadSubSession::CancelDownloadEvent" )

    CLOG_WRITE_FORMAT( "CDownloadSubSession::CancelDownloadEvent iEvent = %d", iEvent )

    if( iEvent )

        {

        iMessage.Complete( KErrCancel );

        iEvent = EFalse;

        }

    }

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

// CDownloadSubSession::Event

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

//

TBool CDownloadSubSession::EventL( TInt32 aDownloadState, TInt32 aProgressState, TInt32 aMoIndex )

    {

    TBool retVal( iEvent );

    CLOG_ENTERFN( "CDownloadSubSession::Event" )

    if( iEvent )

        {

        CLOG_WRITE_FORMAT( " aDownloadState = %d", aDownloadState )

        CLOG_WRITE_FORMAT( " aProgressState = %d", aProgressState )

        CLOG_WRITE_FORMAT( " aMoIndex = %d", aMoIndex )

        TPckgBuf<TInt32> pckgDownloadState( aDownloadState );

        TPckgBuf<TInt32> pckgProgressState( aProgressState );

        TInt ret = iMessage.Write( 0, pckgDownloadState );

	    if( ret != KErrNone )

            {

            CLOG_WRITE_FORMAT( " iMessage.Write( 0, pckgDownloadState ) returned error code: %d", ret )

		    iSession->PanicClient( EBadDescriptor );

            }

        else

            {

            ret = iMessage.Write( 1, pckgProgressState );

	        if( ret != KErrNone )

                {

                CLOG_WRITE_FORMAT( " iMessage.Write( 1, pckgProgressState ) returned error code: %d", ret )

		        iSession->PanicClient( EBadDescriptor );

                }

	     	else

	            {

	            HBufC8* eventAttr = NULL;

	            TInt32 userdata( 0 );

	            iDownload->GetIntAttributeL( EDlAttrUserData, userdata );

	            TInt32 moDownloadedsize( 0 );

	            iDownload->GetIntAttributeL( EDlAttrMultipleMODownloadedSize, moDownloadedsize );

	            TInt32 moLength( 0 );

	            iDownload->GetIntAttributeL( EDlAttrMultipleMOLength, moLength );

	            TInt32 downloadedsize( 0 );

	            iDownload->GetIntAttributeL( EDlAttrDownloadedSize, downloadedsize );

	            TInt32 length( 0 );

	            iDownload->GetIntAttributeL( EDlAttrLength, length );

	            // Mask  media object index with userdata.

			    // For example if aMoIndex = 0x00000004 and userdata = 0x00000005,

			    // then maskData = 0x00040005.

			    TInt32 maskedData = (aMoIndex << 16);

			    maskedData = (maskedData | (userdata & 0x0000FFFF));

	            TRAPD( err, eventAttr = TDMgrUtils::PackEventAttribL( maskedData, moDownloadedsize, downloadedsize, moLength, length ) );           

	            if( KErrNone == err )

	                {      

	                TPtr8 ptr = eventAttr->Des();

	                ret = iMessage.Write( 2, ptr );

	    	        if( ret != KErrNone )

	                    {

	                    CLOG_WRITE_FORMAT( " iMessage.Write( 2, ptr ) returned error code: %d", ret )

	    		        iSession->PanicClient( EBadDescriptor );

	                    }

	                }

	            delete eventAttr;

	            }

            }

        EventComplete( KErrNone );

        }

    CLOG_WRITE_FORMAT( "Event sent: %d", retVal )

    return retVal;

    }

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

// CDownloadSubSession::CreateAttribPackL

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

//

HBufC8* CDownloadSubSession::CreateAttribPackL( TBool aBuffered )

    {

    CLOG_ENTERFN( "CDownloadSubSession::CreateEventAttribPackLC" )

    iAttribs = 

        new (ELeave) CArrayPtrFlat< CDefaultAttrib >( 1 );

    TInt32 value( 0 );

    iDownload->GetIntAttributeL( EDlAttrUserData, value );

    CDefaultAttrib* attrib = CDefaultAttrib::NewL( EDlAttrUserData, value );

    CleanupStack::PushL( attrib );

    iAttribs->AppendL( attrib );

    CleanupStack::Pop( attrib );

    iDownload->GetIntAttributeL( EDlAttrMultipleMODownloadedSize, value );

    attrib = CDefaultAttrib::NewL( EDlAttrMultipleMODownloadedSize, value );

    CleanupStack::PushL( attrib );

    iAttribs->AppendL( attrib );

    CleanupStack::Pop( attrib );

    iDownload->GetIntAttributeL( EDlAttrDownloadedSize, value );

    attrib = CDefaultAttrib::NewL( EDlAttrDownloadedSize, value );

    CleanupStack::PushL( attrib );

    iAttribs->AppendL( attrib );

    CleanupStack::Pop( attrib );

    iDownload->GetIntAttributeL( EDlAttrMultipleMOLength, value );

    attrib = CDefaultAttrib::NewL( EDlAttrMultipleMOLength, value );

    CleanupStack::PushL( attrib );

    iAttribs->AppendL( attrib );

    CleanupStack::Pop( attrib ); 

    iDownload->GetIntAttributeL( EDlAttrLength, value );

    attrib = CDefaultAttrib::NewL( EDlAttrLength, value );

    CleanupStack::PushL( attrib );

    iAttribs->AppendL( attrib );

    CleanupStack::Pop( attrib ); 

    if( aBuffered )

        {

        TBool deleteStr;

        HBufC8* tempBuf = iDownload->GetString8AttributeL( 

                                     EDlAttrReqUrl, 

                                     deleteStr );

        if( deleteStr )

            {

            CleanupStack::PushL( tempBuf );

            }

        TInt length = tempBuf->Length();                             

        attrib = CDefaultAttrib::NewL( EDlAttrReqUrl, tempBuf->Des() );

        CleanupStack::PushL( attrib );

        iAttribs->AppendL( attrib );

        CleanupStack::Pop( attrib );

        if( deleteStr )

            {

            CleanupStack::PopAndDestroy( tempBuf );  // tempBuf

            }

        iDownload->GetIntAttributeL( EDlAttrId, value );    

        attrib = CDefaultAttrib::NewL( EDlAttrId, value );

        CleanupStack::PushL( attrib );

        iAttribs->AppendL( attrib );

        CleanupStack::Pop( attrib );          

        }

    iDownload->GetIntAttributeL( EDlAttrActiveDownload, value );

    attrib = CDefaultAttrib::NewL( EDlAttrActiveDownload, value );

    CleanupStack::PushL( attrib );

    iAttribs->AppendL( attrib );

    CleanupStack::Pop( attrib ); 

    HBufC8* buf = TDMgrUtils::PackedAttributesL( iAttribs );

    iAttribs->ResetAndDestroy();

    delete iAttribs;

    iAttribs = NULL;

    return buf;

    }

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

// CDownloadSubSession::OnError

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

//

void CDownloadSubSession::OnError( TInt aError,

                                   THttpDownloadMgrError aDlError )

    {

    CLOG_ENTERFN( "CDownloadSubSession::OnError" )

    iDownload->OnError( aError, aDlError );