/*

* 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!

	    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 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::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 );

    Write( 1, CurrentMessage(), countPckg );

    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 );