/*

* 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 Client interface of Download Mgr Server.

*

*/

// INCLUDE FILES

#include "DownloadMgrLogger.h"

#include <downloadmgrclient.h>

#include "DownloadMgrServer.h"

#include "DownloadMgrStart.h"

#include "DownloadMgrDef.h"

#include "DownloadMgrDefAttrib.h"

#include "DownloadMgrHandler.h"

#include <e32svr.h>

#include <EscapeUtils.h>

#include <centralrepository.h>

#include "DownloadMgrCRKeys.h"

#include <browseruisdkcrkeys.h>

#include <coddownload.h>

// CONSTANTS

const TInt KHttpDownloadMgrObserverArrayGranularity = 4;

const TInt KHttpDownloadMgrDefalutAttribsGranularity = 4;

const TInt KDefaultMsgSlots = 16;

const TInt KNumOfSubSessions = 16;

_LIT8( KHttpScheme, "http" );

_LIT8( KHttpsScheme, "https" );

// GLOBAL FUNCTIONS

#if defined(_DEBUG)

void DMPanic( TInt aPanicCode )

    {

    User::Panic( _L("DownloadManager"), aPanicCode );

    }

#endif

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

/**

* Extension class.

*/

NONSHARABLE_CLASS( CRHttpDownloadMgrExtension ) : public CBase

    {

    public:  // Constructors and destructor

        /**

        * Two-phased constructor.

        */

        static CRHttpDownloadMgrExtension* NewL();

        /**

        * Destructor.

        */

        virtual ~CRHttpDownloadMgrExtension();

        /*

        * Next uri observer setter function

        */

        void SetNextUriObserver( MHttpDownloadMgrNextUriObserver* aObserver );

        /*

        * Next uri observer getter function

        */

        MHttpDownloadMgrNextUriObserver* NextUriObserver() const;

    protected: // Constructors

        /**

        * C++ default constructor.

        */

        CRHttpDownloadMgrExtension();

        /**

        * By default Symbian 2nd phase constructor is private.

        */

        void ConstructL();

    public:      

        static TInt GetRepositoryValue( TUint32 aSettingId, TInt& aSettingValue );

        static TInt SetRepositoryValue( TUint32 aSettingId, TInt aSettingValue );

    public: // Data

        TInt iEventBroadcastLevel;

        MHttpDownloadMgrNextUriObserver* iNextUriObserver; ///< Not Owned.

        TInt iSessionId;

        TInt iAdjustEventPriorityFlag;

    };

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

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

// CRHttpDownloadMgrExtension::CRHttpDownloadMgrExtension

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

//

CRHttpDownloadMgrExtension::CRHttpDownloadMgrExtension()

:iEventBroadcastLevel( 0 )

,iAdjustEventPriorityFlag( 0 )

    {

    iNextUriObserver = NULL;

    }

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

// CRHttpDownloadMgrExtension::ConstructL

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

//

void CRHttpDownloadMgrExtension::ConstructL()

    {

    CLOG_ENTERFN("CRHttpDownloadMgrExtension::ConstructL");

    }

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

// CRHttpDownloadMgrExtension::NewL

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

//

CRHttpDownloadMgrExtension* CRHttpDownloadMgrExtension::NewL()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// Destructor

CRHttpDownloadMgrExtension::~CRHttpDownloadMgrExtension()

    {

    CLOG_ENTERFN("CRHttpDownloadMgrExtension::~CRHttpDownloadMgrExtension");

    }

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

// CRHttpDownloadMgrExtension::SetNextUriObserver

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

//

void CRHttpDownloadMgrExtension::SetNextUriObserver( MHttpDownloadMgrNextUriObserver* aObserver )

    {

    iNextUriObserver = aObserver;

    }

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

// CRHttpDownloadMgrExtension::NextUriObserver

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

//

MHttpDownloadMgrNextUriObserver* CRHttpDownloadMgrExtension::NextUriObserver() const

    {

    return iNextUriObserver;

    }

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

// CRHttpDownloadMgrExtension::GetRepositoryValue

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

//

TInt CRHttpDownloadMgrExtension::GetRepositoryValue( TUint32 aSettingId, TInt& aSettingValue )

    {

    aSettingValue = KErrNotFound;

    CRepository* rep = NULL;

    TRAPD( err, rep = CRepository::NewL( KCRUidBrowserUiLV ) );

    if( (err == KErrNone) && rep )

        {

        err = rep->Get( aSettingId, aSettingValue );

        }

    delete rep;

    return err;

    }

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

// CRHttpDownloadMgrExtension::SetRepositoryValue

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

//

TInt CRHttpDownloadMgrExtension::SetRepositoryValue( TUint32 aSettingId, TInt aSettingValue )

    {

    CRepository* rep = NULL;

    TRAPD( err, rep = CRepository::NewL( KCRUidBrowserUiLV ) );

    if( (err == KErrNone) && rep )

        {

        err = rep->Set( aSettingId, aSettingValue );

        }

    delete rep;

    return err;

    }

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

// RHttpDownloadMgr::RHttpDownloadMgr

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

//

EXPORT_C RHttpDownloadMgr::RHttpDownloadMgr()

	{

    // Reset data members as R-objects are not zero'd.

    iAppUid = TUid::Null();

    iDownloadArray = NULL;

    iObservers = NULL;

    iDefaultAttribs = NULL;

    iManagerHandler = NULL;

    iExtension = NULL;

	}

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

// RHttpDownloadMgr::ConnectL

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

//

EXPORT_C void RHttpDownloadMgr::ConnectL( TUid aAppUid,

                                          MHttpDownloadMgrObserver& aObserver,

                                          TBool aMaster )

    {

	CLOG_CREATE;

    __ASSERT_DEBUG( !Handle(), DMPanic( KErrAlreadyExists ) );

    TRAPD( err, DoConnectL( aAppUid, aObserver, aMaster ) );

    if( err )

        {

        Close();

        User::Leave( err );

        }

    }

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

// RHttpDownloadMgr::DoConnectL

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

//

void RHttpDownloadMgr::DoConnectL( TUid aAppUid,

                                   MHttpDownloadMgrObserver& aObserver,

                                   TBool aMaster )   

	{

    CLOG_ENTERFN( "RHttpDownloadMgr::ConnectL" );

    TInt error = KErrNone;

    RProcess server;

    error = server.Create( KDownloadMgrServerExe, TPtr( NULL, 0 ),

                           TUidType( KNullUid, KNullUid, KUidDownloadMgrSrvExe ) );

    CLOG_WRITE_FORMAT( "RHttpDownloadMgr::ConnectL after process creation, err %d", error );

    if( !error )

        {

        TRequestStatus status;

        server.Rendezvous( status );

        if( status != KRequestPending )

            {

            CLOG_WRITE( "RHttpDownloadMgr::ConnectL pending status error." );

            server.Kill( 0 );

            }

        else

            {

            CLOG_WRITE( "RHttpDownloadMgr::ConnectL pending resume server." );

            server.Resume( );

            }

        User::WaitForRequest( status );

        error = ( server.ExitType() == EExitPanic ) ? KErrGeneral : status.Int();

        server.Close();

        }

    User::LeaveIfError( error );

    CLOG_WRITE( "Creating..." );

    User::LeaveIfError(  CreateSession( KDownloadMgrServerName, Version(), KDefaultMsgSlots ) );

    CLOG_WRITE( "Created" );

    CLOG_WRITE( "Starting initialization" );

    InitializeL( aAppUid, aObserver, aMaster );

    CLOG_WRITE( "Init OK" );

	}

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

// RHttpDownloadMgr::InitializeL

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

//

void RHttpDownloadMgr::InitializeL( TUid aAppUid,

                                    MHttpDownloadMgrObserver& aObserver,

                                    TBool aMaster )

    {

    CLOG_ENTERFN( "RHttpDownloadMgr::InitializeL" )

    iAppUid = aAppUid;

    AddObserverL( aObserver );

    iExtension = CRHttpDownloadMgrExtension::NewL();

    CLOG_ATTACH( iExtension, this );

    iDownloadArray = new (ELeave) CArrayPtrFlat< RHttpDownload >( 1 );

    if( aMaster )

        {

        iManagerHandler = new (ELeave) CDownloadMgrHandler ( this );

        CLOG_ATTACH( iManagerHandler, this );

        iManagerHandler->StartL();

        }

    TPckg<TUid> uidPckg( iAppUid );

    TInt count( 0 );

    TPckg<TInt> pckgCount( count );

    TPckg<TInt> sessionId( iExtension->iSessionId );

    // 0st param - application UID

    // 1st param - the amount of downloads at server side belongs to the same UID

    // 2st param - master flag

    // 3rd param - session id

    User::LeaveIfError( SendReceive( EHttpDownloadMgrInitialize, 

                                     TIpcArgs( &uidPckg, &pckgCount, aMaster, 

                                     &sessionId ) ) );

    CLOG_NAME_2( _L("Session_%x_%x"), aAppUid.iUid, iExtension->iSessionId );

    CLOG_WRITE_FORMAT( "count: %d", count )

    // There are downloads at server side which needs to be attached

    if( count )

        {

        // Create a buffer which will contain the handles.

        TPckgBuf<TInt> arrayPckg;

        HBufC8* buf = HBufC8::NewLC( count*arrayPckg.Size() );

        // Get the handles from the server

        TPtr8 ptr = buf->Des();

        AttachL( ptr );

        // Create subsessions one by one.

        for( TInt i = 0; i < count; i++ )

            {

            RHttpDownload* download = new (ELeave) RHttpDownload ( this );

            CleanupStack::PushL( download );

            // Parse the handle from the buffer.

            arrayPckg.Copy( buf->Mid( i*arrayPckg.Size(), arrayPckg.Size() ) );

            // Attach subsession to the server by the handle.

            download->AttachL( arrayPckg() );

            TBool isCodDownload ( EFalse );

            download->GetBoolAttribute ( EDlAttrCodDownload , isCodDownload );

            if( isCodDownload )

            	{

            	//paused Download

            	download->InitPausedCodDownloadL( iAppUid );

            	// Update CodData in Download Mgr Server

            	HBufC8* mediaInfo8 = NULL;

            	if(download->iCodDownload)

            	    {

            	    mediaInfo8 = download->iCodDownload->UpdatedDownloadDataL();

            	    }

    	    	if (mediaInfo8)

    	        	{

    	        	download->SetDownloadDataAttribute(*mediaInfo8);

    	        	delete mediaInfo8;

    	        	// Buffer attributes in CRHttpDownloadExtension class

    	        	download->BufferAttributesL();

    	        	}

                User::LeaveIfError( download->GetProductDownloadedSize( ) );                	        	

            	}

            AddToArrayL( download );	

            CleanupStack::Pop( download ); //download

            }

        CleanupStack::PopAndDestroy( buf ); // buf

        }

    }

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

// RHttpDownloadMgr::AttachL

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

//

void RHttpDownloadMgr::AttachL( TDes8& aBuf )

    {

    CLOG_ENTERFN( "RHttpDownloadMgr::AttachL" )

    // 0st param - buffer will contain handles.

    // The handles idetifies the download subsessions.

    User::LeaveIfError( SendReceive( EHttpDownloadMgrAttach, 

                                     TIpcArgs( &aBuf ) ) );

    }

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

// RHttpDownloadMgr::CloseDownload

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

//

void RHttpDownloadMgr::CloseDownload( RHttpDownload* aElement )

    {

    CLOG_ENTERFN( "RHttpDownloadMgr::CloseDownload" );

    // As this class owns the array of subsessions, this role is 

    // to close them.

    RemoveFromArray( aElement );

    aElement->Close();

    delete aElement;

    aElement = NULL;

    }

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

// RHttpDownloadMgr::Version

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

//

EXPORT_C TVersion RHttpDownloadMgr::Version( void ) const

	{

	return TVersion( KDownloadMgrMajorVersionNumber,

                     KDownloadMgrMinorVersionNumber,

                     KDownloadMgrBuildVersionNumber );

	}

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

// RHttpDownloadMgr::Close

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

//

EXPORT_C void RHttpDownloadMgr::Close()

	{

 	if( !Handle() )

 	    {

 	    return;

 	    }

    CLOG_WRITE( "RHttpDownloadMgr::Close" )

    if( iDownloadArray )

        {

        TInt count = iDownloadArray->Count();

        while( count-- )

            {

            CLOG_WRITE_FORMAT( "Close download count[%d]", count );

		    RHttpDownload* download = (*iDownloadArray)[count];

		    CloseDownload( download );

            }

        iDownloadArray->Reset();

        delete iDownloadArray;

        iDownloadArray = NULL;

        }

    if( iExtension )

        {

        delete iExtension;

        iExtension = NULL;

        }

    if( iObservers )

        {

        iObservers->Reset();

        delete iObservers;

        iObservers = NULL;

        }

    if( iDefaultAttribs )

        {

        iDefaultAttribs->ResetAndDestroy();

        delete iDefaultAttribs;

        iDefaultAttribs = NULL;

        }

    if( iManagerHandler )

        {

        iManagerHandler->Cancel();

        delete iManagerHandler;

        iManagerHandler = NULL;

        }

	RHandleBase::Close();

	CLOG_CLOSE;

	}

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

// RHttpDownloadMgr::AddObserverL

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

//

EXPORT_C void RHttpDownloadMgr::AddObserverL( MHttpDownloadMgrObserver& aObserver )

    {

    __ASSERT_DEBUG( Handle(), DMPanic( KErrDisconnected ) );

    CLOG_ENTERFN( "RHttpDownloadMgr::AddObserverL" )

	if ( iObservers == NULL )

        {

		iObservers = new (ELeave) CDownloadMgrObserver( 

            KHttpDownloadMgrObserverArrayGranularity );

        }

    TInt index( 0 );

    if ( FindObserver( aObserver, index ) == KErrNone )

        {

        // Observer already added.

        }

    else

        {

	    iObservers->AppendL( &aObserver );

        }

    }

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

// RHttpDownloadMgr::RemoveObserver

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

//

EXPORT_C void RHttpDownloadMgr::RemoveObserver( MHttpDownloadMgrObserver& aObserver )

    {

    __ASSERT_DEBUG( Handle(), DMPanic( KErrDisconnected ) );

    CLOG_ENTERFN( "RHttpDownloadMgr::RemoveObserver" )

    if ( iObservers )

        {

        TInt index( 0 );

        if ( FindObserver( aObserver, index ) != KErrNone )

            {

            // Observer not found. Do nothing.

            }

        else

            {

            // Observer found.

            iObservers->Delete( index );

            // Free up memory.

            if ( iObservers->Count() == 0 )

                {

                delete iObservers;

                iObservers = NULL;

                }

            }

        }