/*

* Copyright (c) 2002-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:  ?Description

*

*/

// INCLUDE FILES

	//User Includes

#include "HttpDownloadManagerServerEngine.h"

#include "HttpClientApp.h"

#include "HttpDownloadMgrLogger.h"

	//System Includes

#include <bldvariant.hrh>

#include <e32std.h>

#include <centralrepository.h>

#include <DocumentHandler.h>

#include <FeatMgr.h>

#ifdef RD_MULTIPLE_DRIVE

#include <driveinfo.h>

#endif //RD_MULTIPLE_DRIVE

#ifdef __DOWNLOADMGR_CLOG__

#pragma message ( "DMgr Engine logger enabled" )

#endif

// EXTERNAL DATA STRUCTURES

//extern  ?external_data;

// EXTERNAL FUNCTION PROTOTYPES  

//extern ?external_function( ?arg_type,?arg_type );

// CONSTANTS

//const ?type ?constant_var = ?constant;

_LIT( KDmDefaultDir, "c:\\system\\dmgr\\" );

_LIT( KDefaultDriveList, "C;E" );

#ifdef RD_MULTIPLE_DRIVE

_LIT( KDefaultDriveListSep, ";" );

#endif

// TODO: Modify KGrandMasterAppUid if stand-alone DMgr app's uid is known")

// MACROS

//#define ?macro ?macro_def

// LOCAL CONSTANTS AND MACROS

//const ?type ?constant_var = ?constant;

//#define ?macro_name ?macro_def

// MODULE DATA STRUCTURES

//enum ?declaration

//typedef ?declaration

// LOCAL FUNCTION PROTOTYPES

//?type ?function_name( ?arg_type, ?arg_type );

// FORWARD DECLARATIONS

//class ?FORWARD_CLASSNAME;

// ============================= LOCAL FUNCTIONS ===============================

#if defined(_DEBUG)

void DMPanic( TInt aPanicCode )

    {

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

    }

#endif

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

CMMCNotifier::CMMCNotifier( RProperty* aProperty )

	: CActive( EPriorityStandard ) 

	,iProperty( aProperty )

	{

    CActiveScheduler::Add( this );

	}

CMMCNotifier::~CMMCNotifier()

    {

    Cancel();

    }

void CMMCNotifier::StartObserving( MMMCObserver* aObserver )

	{

	__ASSERT_DEBUG( !IsActive(), User::Panic( KNullDesC, KErrInUse) );

	iObserver = aObserver;

	iProperty->Subscribe( iStatus );

	SetActive();

	}

void CMMCNotifier::RunL()

    {

	TInt value( 0 );

	iProperty->Get( value);

	iObserver->MMCModeChanged( value == 1 );

	iProperty->Subscribe( iStatus );

	SetActive();

    }

void CMMCNotifier::DoCancel()

    {

    iProperty->Cancel();

    }

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

// CHttpDownloadManagerServerEngine::CHttpDownloadManagerServerEngine

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CHttpDownloadManagerServerEngine::CHttpDownloadManagerServerEngine()

    : iMMCUniqueID( (TUint)KErrNotFound ),

    iFeatProgressiveDownload(EFalse)

    {

    CLOG_CREATE;

    }

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

// CHttpDownloadManagerServerEngine::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CHttpDownloadManagerServerEngine::ConstructL()

    {

    CLOG_NAME( _L("Engine") );

    LOGGER_ENTERFN( "ConstructL()" );

    User::LeaveIfError( iRfs.Connect() );

	User::LeaveIfError(iRfs.ShareProtected());

    iDocHandler = CDocumentHandler::NewL();

    iFeatProgressiveDownload = FeatureManager::FeatureSupported( KFeatureIdBrowserProgressiveDownload );

    iProperty = new (ELeave) RProperty;

    CLOG_ATTACH( iProperty, this );

    iProperty->Attach( KPSUidUikon,KUikMMCInserted );

    iMMCNotifier = new (ELeave) CMMCNotifier( iProperty );

    CLOG_ATTACH( iMMCNotifier, this );

    iMMCNotifier->StartObserving( this );

    QueryMMCUniqueId();

    QueryDriveListL();

    iClientApps = new (ELeave) CArrayPtrFlat<CHttpClientApp>(2);

    // make directory for the server

    // No problem if it already exists

    TInt error = iRfs.MkDirAll( KDmDefaultDir );

    if( error != KErrNone && error != KErrAlreadyExists )

        // leave if makedir failed in some way

        // don't leave if already exists

        {

        CLOG_WRITE8_1( "MkDirAll: %d", error );

        User::Leave( error );

        }

    LoadClientsL();

    // This code generates a unique id for the next download

    // client will create. It is always the the highest unique

    // id of all downloads + 1.

    iNextDownloadId = 1;

    for( TInt apps = 0; apps < iClientApps->Count(); ++apps )

        {

        CArrayPtrFlat<CHttpDownload>* allDownloads = (*iClientApps)[apps]->Downloads();

        for( TInt i = 0; i < allDownloads->Count(); ++i )

            {

            if( iNextDownloadId <= (*allDownloads)[i]->Id() )

                {

                iNextDownloadId = (*allDownloads)[i]->Id() + 1;

                }

            }

        }

    error = iSocketServ.Connect();

    User::LeaveIfError(error);

    }

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

// CHttpDownloadManagerServerEngine::NewL

// Two-phased constructor.

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

//

EXPORT_C CHttpDownloadManagerServerEngine* 

                                    CHttpDownloadManagerServerEngine::NewL()

    {

    CHttpDownloadManagerServerEngine* self = 

                            new( ELeave ) CHttpDownloadManagerServerEngine();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// Destructor

CHttpDownloadManagerServerEngine::~CHttpDownloadManagerServerEngine()

    {

    CLOG_WRITE( "~CHttpDownloadManagerServerEngine" );

    CloseEngine( EFalse );

    CLOG_CLOSE;

    }

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

// CHttpDownloadManagerServerEngine::CloseEngine

// ?implementation_description

// (other items were commented in a header).

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

//

EXPORT_C void CHttpDownloadManagerServerEngine::CloseEngine( TBool /*bStore*/ )

    {

    LOGGER_ENTERFN( "CloseEngine" );

    iEngineClosing = ETrue;

    if( iClientApps )

        {

        iClientApps->ResetAndDestroy();

        delete iClientApps; iClientApps = NULL;

        }

    if( iMMCNotifier )

        {

        iMMCNotifier->Cancel();

        delete iMMCNotifier; iMMCNotifier = NULL;

        }

    delete iProperty; iProperty = NULL;

    iRfs.Close();

    iSocketServ.Close();

    delete iDocHandler; iDocHandler = NULL;

    }

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

// CHttpDownloadManagerServerEngine::CreateNewClientAppL

// ?implementation_description

// (other items were commented in a header).

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

//

EXPORT_C CHttpClientAppInstance* 

    CHttpDownloadManagerServerEngine::CreateNewClientAppInstanceL( 

                                            TUint32 aAppUid, 

                                            MDownloadStateObserver* aObserver,

                                            TBool aMaster )

    {

    LOGGER_ENTERFN( "CreateNewClientAppInstanceL" );

    // clientApp is stored in iCliendApps array

    CHttpClientApp* clientApp = CreateNewClientAppL( aAppUid );

    CHttpClientAppInstance* instance = 

                        clientApp->CreateNewInstanceL( aObserver,

                                                       aMaster );

    return instance;

    }

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

// CHttpDownloadManagerServerEngine::CloseClientInstance

// ?implementation_description

// (other items were commented in a header).

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

//

EXPORT_C void CHttpDownloadManagerServerEngine::CloseClientInstance( 

                                              CHttpClientAppInstance* aAppInst )

    {

    LOGGER_ENTERFN( "CloseClientInstance" );

    if( !aAppInst )

        {

        return;

        }

    __ASSERT_DEBUG( aAppInst->ClientApp(), DMPanic( KErrArgument ) );

    aAppInst->ClientApp()->CloseInstance( aAppInst );

    }

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

// CHttpDownloadManagerServerEngine::ActiveDownloads

// ?implementation_description

// (other items were commented in a header).

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

//

EXPORT_C TInt CHttpDownloadManagerServerEngine::ActiveDownloads() const

    {

    LOGGER_ENTERFN( "ActiveDownloads" );

    TInt downloads( 0 );

    for( TInt apps = 0; apps < iClientApps->Count(); ++apps )

        {

        CArrayPtrFlat<CHttpDownload>* dlArray = (*iClientApps)[apps]->Downloads();

        for( TInt dl = 0; dl < dlArray->Count(); ++dl )

            {

            if( (*dlArray)[dl]->State() == EHttpDlInprogress )

                {

                ++downloads;

                }

            }

        }

    return downloads;

    }

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

// CHttpDownloadManagerServerEngine::AllDownloadsSizeL

// ?implementation_description

// (other items were commented in a header).

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

//

TInt CHttpDownloadManagerServerEngine::AllDownloadsSizeL(const CHttpDownload *aDownload) const

    {

    LOGGER_ENTERFN( "AllDownloadsSize" );

    TInt allDownloadsSize( 0 );

    TInt numClientApps = iClientApps->Count();

    for( TInt apps = 0; apps < numClientApps; ++apps )

        {

        CArrayPtrFlat<CHttpDownload>* dlArray = (*iClientApps)[apps]->Downloads();

        TInt numDownloads = dlArray->Count();

        for( TInt dl = 0; dl < numDownloads; ++dl )

            {

            if( ( aDownload != (*dlArray)[dl]) && (*dlArray)[dl]->State() != EHttpDlMultipleMOCompleted)

                {

                TInt32 totalSize(0);

                TInt32 downloadedSize(0);

                (*dlArray)[dl]->GetIntAttributeL(EDlAttrMultipleMOLength, totalSize);

                (*dlArray)[dl]->GetIntAttributeL(EDlAttrMultipleMODownloadedSize, downloadedSize);

                //Do not conside the downloads with unknown size

                if(KDefaultContentLength != totalSize)

                	allDownloadsSize += (totalSize - downloadedSize);

                }

            }

        }

    return allDownloadsSize;

    }

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

// CHttpDownloadManagerServerEngine::AllDownloadsSizeInDriveL

// ?implementation_description

// (other items were commented in a header).

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

//

TInt CHttpDownloadManagerServerEngine::AllDownloadsSizeInDriveL(const CHttpDownload *aDownload, TInt aDriveId) const

    {

    LOGGER_ENTERFN( "AllDownloadsSizeInDriveL" );

    TInt allDownloadsSize( 0 );

    TInt numClientApps = iClientApps->Count();

    for( TInt apps = 0; apps < numClientApps; ++apps )

        {

        CArrayPtrFlat<CHttpDownload>* dlArray = (*iClientApps)[apps]->Downloads();

        TInt numDownloads = dlArray->Count();

        for( TInt dl = 0; dl < numDownloads; ++dl )

            {

            if( ( aDownload != (*dlArray)[dl]) && (*dlArray)[dl]->State() != EHttpDlMultipleMOCompleted 

                  && aDriveId == (*dlArray)[dl]->GetDestinationDriveID())

                {

                TInt32 totalSize(0);

                TInt32 downloadedSize(0);

                (*dlArray)[dl]->GetIntAttributeL(EDlAttrMultipleMOLength, totalSize);

                (*dlArray)[dl]->GetIntAttributeL(EDlAttrMultipleMODownloadedSize, downloadedSize);

                //Do not conside the downloads with unknown size

                if(KDefaultContentLength != totalSize)

                	allDownloadsSize += (totalSize - downloadedSize);

                }

            }

        }

    return allDownloadsSize;

    }

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

// CHttpDownloadManagerServerEngine::IsDownloadAttached

// ?implementation_description

// (other items were commented in a header).

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

//

TBool CHttpDownloadManagerServerEngine::IsAttachedAlready(TInt32 aDownloadId)

{

    LOGGER_ENTERFN( "IsAttachedAlready" );

    for( TInt apps = 0; apps < iClientApps->Count(); ++apps )

        {

        CArrayPtrFlat<CHttpDownload>* dlArray = (*iClientApps)[apps]->Downloads();

        for( TInt dl = 0; dl < dlArray->Count(); ++dl )

            {

            if( (*dlArray)[dl]->Id() == aDownloadId )

                {

				if ((*dlArray)[dl]->PDClientAppInstance())

					{

						return ETrue;

					}

                }

            }

        }

    return EFalse;

}

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

// CHttpDownloadManagerServerEngine::FindDownload

// ?implementation_description

// (other items were commented in a header).

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

//

CHttpDownload* 

    CHttpDownloadManagerServerEngine::FindDownload( TInt32 aDownloadId )

    {

    for( TInt apps = 0; apps < iClientApps->Count(); ++apps )

        {

        CArrayPtrFlat<CHttpDownload>* allDownloads = (*iClientApps)[apps]->Downloads();

        for( TInt i = 0; i < allDownloads->Count(); ++i )

            {

            if( (*allDownloads)[i]->Id() == aDownloadId )

                {

                return (*allDownloads)[i];

                }

            }

        }

    return NULL;        

    }

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

// CHttpDownloadManagerServerEngine::CreateNewClientAppL

// ?implementation_description

// (other items were commented in a header).

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

//

CHttpClientApp* 

    CHttpDownloadManagerServerEngine::CreateNewClientAppL( TUint32 aAppUid )

    {

    LOGGER_ENTERFN( "CreateNewClientAppL" );

    CHttpClientApp* clientApp = NULL;

    // Is this client app already registered?

    for( TInt index = 0; index < iClientApps->Count(); ++index )

        {

        if( (*iClientApps)[index]->AppUid() == aAppUid )

            {

            // we found it

            clientApp = (*iClientApps)[index];

            clientApp->LoadClientInfoL(KNullDesC);

            break;

            }

        }

    if( !clientApp )

        {

        clientApp = CHttpClientApp::NewL( aAppUid,

                                          this );

        CleanupStack::PushL( clientApp );

        iClientApps->AppendL( clientApp );

        CleanupStack::Pop( clientApp );

        }

    return clientApp;

    }

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

// CHttpDownloadManagerServerEngine::LoadClientsL

// ?implementation_description

// (other items were commented in a header).

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

//

void CHttpDownloadManagerServerEngine::LoadClientsL()

    {

    LOGGER_ENTERFN( "LoadClientsL" );

    CDir* dirs = 0;

    // hidden + system + dir + only these

    TUint mask = KEntryAttMatchMask | KEntryAttMatchExclusive; 

    User::LeaveIfError( iRfs.GetDir( KDmDefaultDir, 

                                     mask, 

                                     EAscending | EDirsFirst, 

                                     dirs) );

    if( dirs && dirs->Count() )

        {

        CleanupStack::PushL( dirs );

        for( TInt ii = 0; ii < dirs->Count(); ++ii )

            {

            TEntry entry = (*dirs)[ii];

            CLOG_WRITE_1( "Found: %S", &entry.iName );

            TUint32 clientUid = CheckClientDirName( entry.iName );

            if( clientUid )