/*
* 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 "DownloadMgrEventQueue.h"

#include "HttpClientAppInstance.h"
#include "HttpDownload.h"
#include <e32svr.h>
#include <basched.h>

// CONSTANTS

// GLOBAL FUNCTIONS

// ---------------------------------------------------------
// CDownloadMgrSession::NewL
// ---------------------------------------------------------
//
CDownloadMgrSession* CDownloadMgrSession::NewL( CDownloadMgrServer* aServer )
	{
    CLOG_ENTERFN_NULL( "CDownloadMgrSession::NewL" )

    CDownloadMgrSession* self = new (ELeave) CDownloadMgrSession();
	CleanupStack::PushL( self );
	self->ConstructL( aServer );
	CleanupStack::Pop( self ); // self

	return self;
	}

// ---------------------------------------------------------
// CDownloadMgrSession::CDownloadMgrSession
// ---------------------------------------------------------
//
CDownloadMgrSession::CDownloadMgrSession()
: iComplete( ETrue )
,iIsMaster( EFalse )
	{
	__DECLARE_NAME( _S( "CDownloadMgrSession" ) );
	
	CLOG_CREATE;
	}


// ---------------------------------------------------------
// CDownloadMgrSession::CDownloadMgrSession
// ---------------------------------------------------------
//
void CDownloadMgrSession::ConstructL( CDownloadMgrServer* aServer )
	{
    CLOG_ENTERFN( "CDownloadMgrSession::ConstructL" )

    iSessionId = aServer->NextSessionId();
    
	// second-phase construct base class
    //CSession2::CreateL();
	iDownloadMgrServer = aServer;
	// create new object index
	iObjectIx = CObjectIx::NewL();
	// initialize the object container using the object container index in the server.
	iObjectContainer = iDownloadMgrServer->NewContainerL();
    // Increment the serves's session count and cancel shutdown timer
    iDownloadMgrServer->IcrementSessions();
    iEventQueue = new (ELeave) CDownloadMgrEventQueue();
    CLOG_ATTACH( iEventQueue, this );
	}

// ---------------------------------------------------------
// CDownloadMgrSession::~CDownloadMgrSession
// ---------------------------------------------------------
//
CDownloadMgrSession::~CDownloadMgrSession() 
	{
    CLOG_WRITE_FORMAT( "CDownloadMgrSession::~CDownloadMgrSession iClientAppInstance %d", iClientAppInstance );
    if( iDownloadMgrServer )
        {
	    CLOG_WRITE_FORMAT( "Number of sessions: %d", iDownloadMgrServer->SessionsCount() );
        }
    TRAP_IGNORE( PauseAllL() );
    if( iDownloadMgrServer )
        {
        iDownloadMgrServer->CloseClientInstance( iClientAppInstance );
        // Decrement the servers's session count and start shutdown timer if nedded
        iDownloadMgrServer->DecrementSessions();
        }
	//delete the object index (this stores the objects for this session)
    //it calls Close() on all reference counting objects in the index.
	delete iObjectIx;
    iObjectIx = NULL;
    if( iDownloadMgrServer )
        {
        // Remove and delete the object container
        iDownloadMgrServer->RemoveContainer( iObjectContainer );
        }
    delete iEventQueue;
    iEventQueue = NULL;
    
    CLOG_CLOSE;
	}


// ---------------------------------------------------------
// CDownloadMgrSession::CounterFromHandle
// ---------------------------------------------------------
//
CDownloadSubSession* CDownloadMgrSession::DownloadFromHandle(TUint aHandle)
    {
    CLOG_ENTERFN( "CDownloadMgrSession::DownloadFromHandle" )
	CDownloadSubSession* download = ( CDownloadSubSession* )iObjectIx->At( aHandle );
	if( download == NULL )
        {
		PanicClient( EBadSubsessionHandle ); 
        }
	return download;
    }


// ---------------------------------------------------------
// CDownloadMgrSession::CounterFromHandle
// ---------------------------------------------------------
//
void CDownloadMgrSession::ServiceL( const RMessage2& aMessage )
	{
    CLOG_ENTERFN( "CDownloadMgrSession::ServiceL" )
	TRAPD( err, DispatchMessageL( aMessage ) );
    if( iComplete || ( KErrNone != err ) )
        {
        // Only the syncron requests has to be completed here!
        if ((!aMessage.IsNull()) && (!CurrentMessage().IsNull())  )
	    aMessage.Complete( err );
        }
	}


// ---------------------------------------------------------
// CDownloadMgrSession::DispatchMessageL
// ---------------------------------------------------------
//
void CDownloadMgrSession::DispatchMessageL( const RMessage2& aMessage )
	{
    CLOG_ENTERFN( "CDownloadMgrSession::DispatchMessageL" )
    CLOG_WRITE_FORMAT( "Message function: %d", aMessage.Function() )
    // Set this false in case of the asyncron requests!!!
    iComplete = ETrue;
    SetCurrentMessage( aMessage );
    
    // Fixed for Bug id - JJUN-78WCJ3 (DownloadMgrServer crashes under IPC attack)
    //This check will make sure that before start of any download, InitializeL() should
    // be called so that all the member variables will be initialized.
    if(aMessage.Function() != EHttpDownloadMgrInitialize && iClientAppInstance == NULL)
        {
        User::Leave(KErrGeneral);
        }
        
    // check for session-relative requests
	switch( aMessage.Function() )
		{
	    case EHttpDownMgrNumOfSubSessions:
	         {
	         GetNumberOfSubsession();
	         return;
	         }
        case EHttpDownloadMgrInitialize:
            {
            InitializeL();
            return;
            }
	    case EHttpDownloadMgrCreateDownload:
            {
		    NewDownloadL();
            return;
            }
        case EHttpDownloadMgrAttach:
            {
            DownloadMgrAttachL();
            return;
            }
        case EHttpDownloadAttach:
            {
            DownloadAttachL();
            return;
            }
		case EHttpDownloadAttachToDownload:
		    {
		    AttachToDownloadL();
		    return;
		    }
        case EHttpDownloadMgrPauseAll:
            {
            PauseAllL();
            return;
            }
        case EHttpDownloadMgrStartAllL:
            {
            StartAllL();
            return;
            }
        case EHttpDownloadMgrResetAll:
            {
            ResetAll();
            return;
            }
        case EHttpDownloadMgrDeleteAll:
            {
            DeleteAll();
            return;
            }
        case EHttpDownloadMgrDisconnect:
            {
            Disconnect();
            return;
            }
        case EHttpDownloadMgrGetIntAttribute:
            {
            GetIntAttributeL();
            return;
            }
        case EHttpDownloadMgrGetBoolAttribute:
            {
            GetBoolAttributeL();
            return;
            }
        case EHttpDownloadMgrGetStringAttribute:
            {
            GetStringAttributeL();
            return;
            }
        case EHttpDownloadMgrGetString8Attribute:
            {
            GetString8AttributeL();
            return;
            }
        case EHttpDownloadMgrSetIntAttribute:
            {
            SetIntAttributeL();
            return;
            }
        case EHttpDownloadMgrSetBoolAttribute:
            {
            SetBoolAttributeL();
            return;
            }
        case EHttpDownloadMgrSetStringAttribute:
            {
            SetStringAttributeL();
            return;
            }
        case EHttpDownloadMgrSetString8Attribute:
            {
            SetString8AttributeL();
            return;
            }
        case EHttpDownloadMgrSessionEventSubscription:
            {
            InitSessionEvent( aMessage );
            // Send event from the queue
            TUint dummy( 0 );
            Event( NULL, (THttpDownloadState)dummy, (THttpProgressState)dummy, dummy );
            // This is an asyncron request will be completed later!
            SetComplete( EFalse );
            return;
            }
        case EHttpDownloadMgrSessionEventCancel:
            {
            CancelMovedEvent();
            return;
            }
		}
	// ok, it must be subsession relative
	CDownloadSubSession* download = DownloadFromHandle( aMessage.Int3() );
    __ASSERT_DEBUG( download, PanicClient( EBadSubsessionHandle ) );

    TRAPD( err, download->DispatchMessageL( aMessage ) );

    if( err )
        {
        download->OnError( err );
        User::Leave( err );
        }
	}

// ---------------------------------------------------------
// CDownloadMgrSession::SetCurrentMessage
// ---------------------------------------------------------
//
void CDownloadMgrSession::SetCurrentMessage( const RMessage2& aMessage )
    {
    iCurrentMessage = aMessage;
    }

// ---------------------------------------------------------
// CDownloadMgrSession::CurrentMessage
// ---------------------------------------------------------
//
const RMessage2& CDownloadMgrSession::CurrentMessage() const
    {
    return iCurrentMessage;
    }

// ---------------------------------------------------------
// CDownloadMgrSession::GetNumberOfSubsession
// ---------------------------------------------------------
//
void CDownloadMgrSession::GetNumberOfSubsession()
    {    
    TInt32 value(0);   
    for( TInt i = 0; i < iObjectIx->Count(); i++ ){
        CDownloadSubSession* downloadSess 
                    = ( CDownloadSubSession* )(*iObjectIx)[i];
         if( downloadSess != NULL ){
         value++;  
         }
        }
    TPckg<TInt32> pckg( value );
    Write( 0, CurrentMessage(), pckg );    
    }

// ---------------------------------------------------------
// CDownloadMgrSession::InitializeL
// ---------------------------------------------------------
//
void CDownloadMgrSession::InitializeL()
    {
    CLOG_ENTERFN( "CDownloadMgrSession::DownloadMgrAttachCountL" )
    iIsMaster = (TBool)CurrentMessage().Int2();

    TUid uid;
    TPckg<TUid> uidPckg( uid );

    Read( 0, uidPckg );

    CreateClientAppInstanceL( uidPckg().iUid );

    // Check how many download we have and return it to the client
    CLOG_WRITE_FORMAT( "CDownloadMgrSession::InitializeL iClientAppInstance %d", iClientAppInstance );
    CArrayPtrFlat<CHttpDownload>* currentDownloads = iClientAppInstance->DownloadsL();
	TPckg<TInt> countPckg( currentDownloads->Count() );
	TPckg<TInt> sessionId( iSessionId );
  if (!CurrentMessage().IsNull())
    Write( 1, CurrentMessage(), countPckg );
  if (!CurrentMessage().IsNull())
    Write( 3, CurrentMessage(), sessionId );

    CLOG_NAME_2( _L("Session_%x_%x"), uidPckg().iUid, iSessionId );

    currentDownloads->Reset();
    delete currentDownloads;
    }

// ---------------------------------------------------------
// CDownloadMgrSession::DownloadMgrAttachL
// ---------------------------------------------------------
//
void CDownloadMgrSession::DownloadMgrAttachL()
    {
    CLOG_ENTERFN( "CDownloadMgrSession::DownloadMgrAttachL" )
    // The client would like to attach the dowmloads were created previously.
    // Here, we create a buffer with the unique handles of download subsessions
    // and copy it to the client's address space.
    CLOG_WRITE_FORMAT( "CDownloadMgrSession::DownloadMgrAttachL iClientAppInstance %d", iClientAppInstance );
    CArrayPtrFlat<CHttpDownload>* currentDownloads = iClientAppInstance->DownloadsL();
    CleanupStack::PushL( currentDownloads );
    TPckgBuf<TInt> arrayPckg;
    HBufC8* buf = HBufC8::NewLC( currentDownloads->Count() * arrayPckg.Size() );
    // Cerate subsessions one by one and write the unique handles to the client.
    // Later the handles is used by the client subsession to attach to the server.
    for( TInt i = 0; i < currentDownloads->Count(); i++ )
        {
        CHttpDownload* httpDownload = (*currentDownloads)[i];
	    // make a new download object
	    CDownloadSubSession* download = CDownloadSubSession::NewL( this, httpDownload );
        CleanupStack::PushL( download );
	    // add object to object container to gererate unique id
	    iObjectContainer->AddL( download );
	    // add object to object index; this returns a unique handle so we can get it again
        CLOG_WRITE_FORMAT( "CDownloadMgrSession::DownloadMgrAttachL, download %d", download );
	    arrayPckg() = iObjectIx->AddL( download );
        CLOG_WRITE_FORMAT( "CDownloadMgrSession::DownloadMgrAttachL, iObjectIx->ActiveCount() %d", iObjectIx->ActiveCount() );
        // Store handle to the subsession. It is used when the URL is checked.
        download->SetHandle( arrayPckg() );
        CleanupStack::Pop( download ); //download
        buf->Des().Append( arrayPckg );
        }
    TPtr8 ptr = buf->Des();

    Write( 0, CurrentMessage(), ptr );

    CleanupStack::PopAndDestroy( buf ); // buf
    currentDownloads->Reset();
    CleanupStack::PopAndDestroy( currentDownloads ); // currentDownloads
    }

// ---------------------------------------------------------
// CDownloadMgrSession::DownloadAttachL
// ---------------------------------------------------------
//
void CDownloadMgrSession::DownloadAttachL()
	{
    CLOG_ENTERFN( "CDownloadMgrSession::DownloadAttachL" )
    // All we have to do to write the handle to the 3rd parameter.
    // The client-server framework will take care of the 3rd parameter
    // whenever the client calls a subsession related service.
    TInt handle = CurrentMessage().Int1();
    TPckg<TInt> handlePckg( handle );
    WriteHandle( handlePckg() );
	}

// ---------------------------------------------------------
// CDownloadMgrSession::AttachToDownloadL
// ---------------------------------------------------------
//
void CDownloadMgrSession::AttachToDownloadL()
    {
    CLOG_ENTERFN( "CDownloadMgrSession::AttachToDownload" )
    __ASSERT_DEBUG( iClientAppInstance, PanicClient( EMultipleInitDownloadEvent ) );

    const TInt32 id = CurrentMessage().Int0();

    CHttpDownload* dl = iClientAppInstance->AttachDownloadL( id );
		if (dl)
		{
			CreateDownloadL( dl );
		}
		else
		{
			User::LeaveIfError(KErrNotFound);
		}
    }

// ---------------------------------------------------------
// CDownloadMgrSession::CreateDownloadL
// ---------------------------------------------------------
//
void CDownloadMgrSession::CreateDownloadL( CHttpDownload* aDownload, TBool aDefAttrib )
	{
	// make a new download object
	CDownloadSubSession* download = CDownloadSubSession::NewL( this, aDownload );
    CleanupStack::PushL( download );
    if( aDefAttrib )
        {
        download->SetDefAttributesL();
        }
	// add object to object container to gererate unique id
	iObjectContainer->AddL( download );
	// add object to object index; this returns a unique handle so we can get it again
    CLOG_WRITE_FORMAT( "CDownloadMgrSession::DownloadMgrAttachL, download %d", download );
	TInt handle = iObjectIx->AddL( download );
    CLOG_WRITE_FORMAT( "CDownloadMgrSession::DownloadMgrAttachL, iObjectIx->ActiveCount() %d", iObjectIx->ActiveCount() );
    // Store handle to the subsession. It is used when the URL is checked.
    download->SetHandle( handle );
    CleanupStack::Pop( download ); //download
	// write the handle to client
    TPckg<TInt> handlePckg( handle );

    Write( 1, CurrentMessage(), handlePckg );

    // write the handle to the framework
	WriteHandle( handle );	
	}

// ---------------------------------------------------------
// CDownloadMgrSession::CreateClientAppInstanceL
// ---------------------------------------------------------
//
void CDownloadMgrSession::CreateClientAppInstanceL( TUint32 aAppUid )
    {
    CLOG_ENTERFN( "CDownloadMgrSession::CreateClientAppInstanceL" )
    if( !iClientAppInstance )
        {
        CLOG_ENTERFN( "CDownloadMgrSession::CreateClientAppInstanceL REALLY!!!" )

        iClientAppInstance = iDownloadMgrServer->CreateNewClientAppInstanceL(
            aAppUid, *this, iIsMaster );
        CLOG_WRITE_FORMAT( "CDownloadMgrSession::CreateClientAppInstanceL iClientAppInstance %d", iClientAppInstance );
        }
    }

// ---------------------------------------------------------
// CDownloadMgrSession::WriteHandle
// ---------------------------------------------------------
//
void CDownloadMgrSession::WriteHandle( TInt aHandle )
    {
    CLOG_ENTERFN( "CDownloadMgrSession::WriteHandle" )
	TPckg<TInt> handlePckg( aHandle );

    TInt res = CurrentMessage().Write( 3, handlePckg );

	if( res != KErrNone )
		{
		iObjectIx->Remove( aHandle );
		PanicClient( EBadDescriptor );
		return;
		}
    }

// ---------------------------------------------------------
// CDownloadMgrSession::NewDownloadL
// ---------------------------------------------------------
//
void CDownloadMgrSession::NewDownloadL()
	{
    CLOG_ENTERFN( "CDownloadMgrSession::NewDownloadL" )

    TInt desLen = CurrentMessage().GetDesLength( 0 );

	HBufC8* urlBuf = HBufC8::NewLC( desLen );
	TPtr8 urlptr = urlBuf->Des();

    Read( 0, urlptr );

    CLOG_WRITE_FORMAT( "CDownloadMgrSession::NewDownloadL iClientAppInstance %d", iClientAppInstance );
    CHttpDownload* httpDownload = 
        iClientAppInstance->CreateNewDownloadL( urlptr );
    iClientAppInstance->SetObserver( this );
    CleanupStack::PopAndDestroy( urlBuf ); // urlBuf
    
    CreateDownloadL( httpDownload, ETrue );
	}

// ---------------------------------------------------------
// CDownloadMgrSession::CreateSubSessionAndSendEventL
// ---------------------------------------------------------
//
TBool CDownloadMgrSession::CreateSubSessionAndSendEventL( CHttpDownload* aDownload,
                                                          TInt32 aDownloadState,
                                                          TInt32 aProgressState,
                                                          TInt32 aMoIndex )
    {
    CLOG_ENTERFN( "CDownloadMgrSession::CreateSubSessionAndSendEventL" )
	// make a new download object
	CDownloadSubSession* download = CDownloadSubSession::NewL( this, aDownload );
    CleanupStack::PushL( download );
	// add object to object container to gererate unique id
	iObjectContainer->AddL( download );
	// add object to object index; this returns a unique handle so we can get it again
    CLOG_WRITE_FORMAT( "CDownloadMgrSession::DownloadMgrAttachL, download %d", download );
	TInt handle = iObjectIx->AddL( download );
    CLOG_WRITE_FORMAT( "CDownloadMgrSession::DownloadMgrAttachL, iObjectIx->ActiveCount() %d", iObjectIx->ActiveCount() );
    // Store handle to the subsession. It is used when the URL is checked.
    download->SetHandle( handle );
    CleanupStack::Pop( download ); //download

    TBool retVal( iEvent );
    if( iEvent )
        {
        TPckg<TInt32> downloadStatePckg( aDownloadState );
        TPckg<TInt32> progressStatePckg( aProgressState );
        
	    // Mask media object index with handle.
	    // For example if aMoIndex = 0x00000004 and handle = 0x00000005,
	    // then maskData = 0x00040005.
	    TInt32 maskedData = ((aMoIndex << (sizeof(TInt32)/2)) | (handle & 0x0000FFFF));
        TPckg<TInt> maskPckg( maskedData );

        Write( 0, iEventMessage, downloadStatePckg );
        Write( 1, iEventMessage, progressStatePckg );
        Write( 2, iEventMessage, maskPckg );

        EventComplete( KErrNone );
        }
    CLOG_WRITE_FORMAT( "Session event sent: %d", retVal )
    return retVal;
    }

// ---------------------------------------------------------
// CDownloadMgrSession::EventComplete
// ---------------------------------------------------------
//
void CDownloadMgrSession::EventComplete( TInt aErrorStatus )
    {
    if( iEvent )
        {
        iEventMessage.Complete( aErrorStatus );
        iEvent = EFalse;
        }
    }

// ---------------------------------------------------------
// CDownloadMgrSession::DeleteDownload
// ---------------------------------------------------------
//
void CDownloadMgrSession::DeleteDownload( TUint aHandle )
	{
    CLOG_ENTERFN( "CDownloadMgrSession::DeleteDownload" )
	// panic if bad handle
	CDownloadSubSession* download = ( CDownloadSubSession* )iObjectIx->At( aHandle );
    CLOG_WRITE_FORMAT( "CDownloadMgrSession::DeleteDownload, download %d", download );
	if( download == NULL )
        {
		PanicClient( EBadCounterRemove );
        }
    //Removes the reference counting object identified by handle number 
    //from this object index and closes it.
    iObjectIx->Remove( aHandle );
	}

// ---------------------------------------------------------
// CDownloadMgrSession::PanicClient
// ---------------------------------------------------------
//
void CDownloadMgrSession::PanicClient( TInt aPanic ) const
	{
    CLOG_ENTERFN( "CDownloadMgrSession::PanicClient" )
    CLOG_WRITE_FORMAT( " aPanic=%d", aPanic )
	_LIT( KTxtDownloadMgrSession,"CDlMgrSession");

    CurrentMessage().Panic( KTxtDownloadMgrSession, aPanic );
	}

/// ---------------------------------------------------------
// CDownloadMgrSession::PauseAllL
// ---------------------------------------------------------
//
void CDownloadMgrSession::PauseAllL()
    {
    CLOG_ENTERFN( "CDownloadMgrSession::PauseAllL" )
    for( TInt i = 0; i < iObjectIx->ActiveCount(); i++ )
        {
        CDownloadSubSession* downloadSess 
            = ( CDownloadSubSession* )(*iObjectIx)[i];
        if( downloadSess == NULL )
            {
            // Already removed.
            }
        else
            {
            downloadSess->PauseL();
            }
        }
    }

/// ---------------------------------------------------------
// CDownloadMgrSession::StartAllL
// ---------------------------------------------------------
//
void CDownloadMgrSession::StartAllL()
    {
    CLOG_ENTERFN( "CDownloadMgrSession::StartAllL" )
    for( TInt i = 0; i < iObjectIx->Count(); i++ )
        {
        CDownloadSubSession* downloadSess 
            = ( CDownloadSubSession* )(*iObjectIx)[i];
        if( downloadSess == NULL )
            {
            // Already removed.
            }
        else
            {
            downloadSess->StartL();
            }
        }
    }

/// ---------------------------------------------------------
// CDownloadMgrSession::ResetAll
// ---------------------------------------------------------
//
void CDownloadMgrSession::ResetAll()
    {
    CLOG_ENTERFN( "CDownloadMgrSession::CancelAll" )
    for( TInt i = 0; i < iObjectIx->ActiveCount(); i++ )
        {
        CDownloadSubSession* downloadSess 
            = ( CDownloadSubSession* )(*iObjectIx)[i];
        if( downloadSess == NULL )
            {
            // Already removed.
            }
        else
            {
            downloadSess->Reset();
            }
        }
    }

/// ---------------------------------------------------------
// CDownloadMgrSession::DeleteAll
// ---------------------------------------------------------
//
void CDownloadMgrSession::DeleteAll()
    {
    CLOG_ENTERFN( "CDownloadMgrSession::DeleteAll" )
    for( TInt i = 0; i < iObjectIx->ActiveCount(); i++ )
        {
        CDownloadSubSession* downloadSess 
            = ( CDownloadSubSession* )(*iObjectIx)[i];
        if( downloadSess == NULL )
            {
            // Already removed.
            }
        else
            {
            downloadSess->Delete();
            }
        }
    }

/// ---------------------------------------------------------
// CDownloadMgrSession::Disconnect
// ---------------------------------------------------------
//
void CDownloadMgrSession::Disconnect()
    {
    CLOG_WRITE_FORMAT( "CDownloadMgrSession::Disconnect iClientAppInstance %d", iClientAppInstance );
    iClientAppInstance->Disconnect();
    }

// ---------------------------------------------------------
// CDownloadMgrSession::Write
// ---------------------------------------------------------
//
void CDownloadMgrSession::Write( TInt aParam, RMessage2 aMessage, TDesC8& aDes )
	{
    CLOG_ENTERFN( "CDownloadMgrSession::Write" )

    TInt ret = aMessage.Write( aParam, aDes );

	if( ret != KErrNone )
        {
		PanicClient( EBadDescriptor );
        }
	}

// ---------------------------------------------------------
// CDownloadMgrSession::Write
// ---------------------------------------------------------
//
void CDownloadMgrSession::Write( TInt aParam, RMessage2 aMessage, TDesC16& aDes )
	{
    CLOG_ENTERFN( "CDownloadMgrSession::Write" )

    TInt ret = aMessage.Write( aParam, aDes );

	if( ret != KErrNone )
        {
		PanicClient( EBadDescriptor );
        }
	}

// ---------------------------------------------------------
// CDownloadMgrSession::Read
// ---------------------------------------------------------
//
void CDownloadMgrSession::Read( TInt aParam, TPtr8& aDes )
	{
    CLOG_ENTERFN( "CDownloadMgrSession::Read" )

    TInt ret = CurrentMessage().Read( aParam, aDes );

	if( ret != KErrNone )
        {
		PanicClient( EBadDescriptor );
        }
	}

// ---------------------------------------------------------
// CDownloadMgrSession::Read
// ---------------------------------------------------------
//
void CDownloadMgrSession::Read( TInt aParam, TPtr16& aDes )
	{
    CLOG_ENTERFN( "CDownloadMgrSession::Read" )

    TInt ret = CurrentMessage().Read( aParam, aDes );

	if( ret != KErrNone )
        {
		PanicClient( EBadDescriptor );
        }
	}

// ---------------------------------------------------------
// CDownloadMgrSession::Event
// ---------------------------------------------------------
//
void CDownloadMgrSession::Event( CHttpDownload* aDownload, 
                                 THttpDownloadState aDlState,
                                 THttpProgressState aProgState,
                                 TInt32 aMoIndex )
    {
    CLOG_ENTERFN( "CDownloadMgrSession::Event" )
    TBool not_sent( ETrue );
    // First we add the download to the queue then send the next event.
    // aDownload could be NULL, this case we send the next event.
    // If aDownload == NULL the state parameters are ignored. (They don't hold information)
    if( aDownload )
        {
        if( !iEventQueue->In( aDownload, aDlState, aProgState, aMoIndex ) )
            {
            // OOM
            return;
            }
        }
    // Then we send an event from the queue
    if( !iEventQueue->IsEmpty() )
        {
        TInt32 downloadState( 0 );
        TInt32 progressState( 0 );
        TInt32 mediaIndex( 0 );

        CHttpDownload* download = iEventQueue->Next( downloadState, progressState, mediaIndex );
        for( TInt i = 0; i < iObjectIx->Count(); i++ )
            {
            CLOG_WRITE_FORMAT( "CDownloadMgrSession::Event, i %d", i );
            CDownloadSubSession* downloadSess 
                = ( CDownloadSubSession* )(*iObjectIx)[i];
            CLOG_WRITE_FORMAT( "CDownloadMgrSession::Event, downloadSess %d", downloadSess );
            if( downloadSess == NULL )
                {
                // Already removed.
                }
            else if ( downloadSess->IsDownload( download ) )
                {
                CLOG_WRITE_FORMAT( "Download: 0x%x", download )
                CLOG_WRITE_FORMAT( "State: %d", downloadState )
                CLOG_WRITE_FORMAT( "Progress: %d",progressState )
                CLOG_WRITE_FORMAT( "Media Index: %d",mediaIndex )
                
                TBool isSend( EFalse );
                TRAP_IGNORE( isSend = downloadSess->EventL( downloadState, progressState, mediaIndex ) );
                if( isSend )
                    {
                    // the event was sent, it can be removed from the queue
                    iEventQueue->Out();
                    not_sent = EFalse;
                    }
                }
            }

        // Then we must deal with the moved event 
        // if it has not been sent and the event handler is initialized
        if( (downloadState == EHttpDlMoved) && not_sent )
            {
            TBool retVal( EFalse );
            TRAPD( err, retVal = CreateSubSessionAndSendEventL( aDownload, downloadState, progressState, mediaIndex ) );
            
            if( err )
            	{
            	// Do't care, never leave
            	}

            if ( !retVal )
                {
                //OOM
                return;
                }
            else
                {
                // the event was sent, it can be removed from the queue
                iEventQueue->Out();
                not_sent = EFalse;
                }
            }
        }
    }

// ---------------------------------------------------------
// CDownloadMgrSession::SetComplete
// ---------------------------------------------------------
//
void CDownloadMgrSession::SetComplete( TBool aComplete )
    {
    iComplete = aComplete;
    }

// ---------------------------------------------------------
// CDownloadMgrSession::GetIntAttributeL
// ---------------------------------------------------------
//
void CDownloadMgrSession::GetIntAttributeL()
    {
    CLOG_ENTERFN( "CDownloadMgrSession::GetIntAttributeL" )

    const TInt attr = CurrentMessage().Int0();
    TInt32 value;

    CLOG_WRITE_FORMAT( "CDownloadMgrSession::GetIntAttributeL iClientAppInstance %d", iClientAppInstance );
    iClientAppInstance->GetIntAttributeL( (THttpDownloadMgrAttrib)attr, value );

    TPckg<TInt32> pckg( value );

    Write( 1, CurrentMessage(), pckg );
    }

// ---------------------------------------------------------
// CDownloadMgrSession::GetBoolAttributeL
// ---------------------------------------------------------
//
void CDownloadMgrSession::GetBoolAttributeL()
    {
    CLOG_ENTERFN( "CDownloadMgrSession::GetBoolAttributeL" )

    const TInt attr = CurrentMessage().Int0();
    TBool value;

    CLOG_WRITE_FORMAT( "CDownloadMgrSession::GetBoolAttributeL iClientAppInstance %d", iClientAppInstance );
    iClientAppInstance->GetBoolAttributeL( (THttpDownloadMgrAttrib)attr, value );

    TPckg<TBool> pckg( value );

    Write( 1, CurrentMessage(), pckg );
    }

// ---------------------------------------------------------
// CDownloadMgrSession::GetStringAttributeL
// ---------------------------------------------------------
//
void CDownloadMgrSession::GetStringAttributeL()
    {
    CLOG_ENTERFN( "CDownloadMgrSession::GetStringAttributeL" )
    const TInt attr = CurrentMessage().Int0();

    CLOG_WRITE_FORMAT( "CDownloadMgrSession::GetStringAttributeL iClientAppInstance %d", iClientAppInstance );

    TBool deleteStr;
    HBufC* attrStr = iClientAppInstance->GetStringAttributeL( 
                                            (THttpDownloadMgrAttrib)attr,
                                            deleteStr );
    TPtr value( attrStr->Des() );

    Write( 1, CurrentMessage(), value );

    if( deleteStr )
        {
        delete attrStr;
        }
    }

// ---------------------------------------------------------
// CDownloadMgrSession::GetStringAttributeL
// ---------------------------------------------------------
//
void CDownloadMgrSession::GetString8AttributeL()
    {
    CLOG_ENTERFN( "CDownloadMgrSession::GetString8AttributeL" )
    const TInt attr = CurrentMessage().Int0();

    CLOG_WRITE_FORMAT( "CDownloadMgrSession::GetStringAttributeL iClientAppInstance %d", iClientAppInstance );

    TBool deleteStr;
    HBufC8* attrStr = iClientAppInstance->GetString8AttributeL( 
                                            (THttpDownloadMgrAttrib)attr,
                                            deleteStr );
    TPtr8 value( attrStr->Des() );

    Write( 1, CurrentMessage(), value );

    if( deleteStr )
        {
        delete attrStr;
        }
    }

// ---------------------------------------------------------
// CDownloadMgrSession::SetIntAttributeL
// ---------------------------------------------------------
//
void CDownloadMgrSession::SetIntAttributeL()
    {
    CLOG_ENTERFN( "CDownloadMgrSession::SetIntAttributeL" )
    const TInt attr = CurrentMessage().Int0();
    const TInt32 value = CurrentMessage().Int1();
    CLOG_WRITE_FORMAT( "CDownloadMgrSession::SetIntAttributeL iClientAppInstance %d", iClientAppInstance );
    iClientAppInstance->SetIntAttributeL( (THttpDownloadMgrAttrib)attr, value );
    }
        
// ---------------------------------------------------------
// CDownloadMgrSession::SetBoolAttributeL
// ---------------------------------------------------------
//
void CDownloadMgrSession::SetBoolAttributeL()
    {
    CLOG_ENTERFN( "CDownloadMgrSession::SetBoolAttributeL" )
    const TInt attr = CurrentMessage().Int0();
    const TBool value = (TBool)CurrentMessage().Int1();
    CLOG_WRITE_FORMAT( "CDownloadMgrSession::SetBoolAttributeL iClientAppInstance %d", iClientAppInstance );
    iClientAppInstance->SetBoolAttributeL( (THttpDownloadMgrAttrib)attr, value );
    }
		
// ---------------------------------------------------------
// CDownloadMgrSession::SetStringAttributeL
// ---------------------------------------------------------
//
void CDownloadMgrSession::SetStringAttributeL()
    {
    CLOG_ENTERFN( "CDownloadMgrSession::SetStringAttributeL" )
    const TInt attr = CurrentMessage().Int0();

    TInt desLen = CurrentMessage().GetDesLength( 1 );

	HBufC* writeBuf = HBufC::NewLC( desLen );
	TPtr initptr = writeBuf->Des();

    Read( 1, initptr );

    CLOG_WRITE_FORMAT( "CDownloadMgrSession::SetStringAttributeL iClientAppInstance %d", iClientAppInstance );
    iClientAppInstance->SetStringAttributeL( (THttpDownloadMgrAttrib)attr, initptr );
    CleanupStack::PopAndDestroy( writeBuf ); // writeBuf
    }

// ---------------------------------------------------------
// CDownloadMgrSession::SetString8AttributeL
// ---------------------------------------------------------
//
void CDownloadMgrSession::SetString8AttributeL()
    {
    CLOG_ENTERFN( "CDownloadMgrSession::SetString8AttributeL" )
    const TInt attr = CurrentMessage().Int0();

    TInt desLen = CurrentMessage().GetDesLength( 1 );

	HBufC8* writeBuf = HBufC8::NewLC( desLen ); 
	TPtr8 initptr = writeBuf->Des();

    Read( 1, initptr );

    CLOG_WRITE_FORMAT( "CDownloadMgrSession::SetString8AttributeL iClientAppInstance %d", iClientAppInstance );
    iClientAppInstance->SetStringAttributeL( (THttpDownloadMgrAttrib)attr, initptr );
    CleanupStack::PopAndDestroy( writeBuf ); // writeBuf;
    }

/// ---------------------------------------------------------
// CDownloadMgrSession::InitSessionEvent
// ---------------------------------------------------------
//
void CDownloadMgrSession::InitSessionEvent( const RMessage2& aMessage )
    {
    CLOG_ENTERFN( "CDownloadMgrSession::InitMovedEvent" )
    __ASSERT_DEBUG( iEvent == EFalse, PanicClient( EMultipleInitDownloadEvent ) );
    iEventMessage = aMessage;
    iEvent = ETrue;
    }

/// ---------------------------------------------------------
// CDownloadMgrSession::CancelMovedEvent
// ---------------------------------------------------------
//
void CDownloadMgrSession::CancelMovedEvent()
    {
    CLOG_ENTERFN( "CDownloadMgrSession::CancelMovedEvent" )
    if( iEvent )
        {
        iEventMessage.Complete( KErrCancel );
        iEvent = EFalse;
        }
    }

/// ---------------------------------------------------------
// CDownloadMgrSession::RemoveFromQueue
// ---------------------------------------------------------
//
void CDownloadMgrSession::RemoveFromQueue( CHttpDownload* aDownload )
    {
    iEventQueue->Remove( aDownload );
    }

/// ---------------------------------------------------------
// CDownloadMgrSession::SessionId
// ---------------------------------------------------------
//
TInt CDownloadMgrSession::SessionId() const
    {
    return iSessionId;
    }

/// ---------------------------------------------------------
// CDownloadMgrSession::ClientAppInstance
// ---------------------------------------------------------
//
CHttpClientAppInstance* CDownloadMgrSession::ClientAppInstance()const
    {
    return iClientAppInstance;
    }
