/*

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

* All rights reserved.

* This component and the accompanying materials are made available

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

*

*/

#include    <e32property.h>

#include    "upnpavdevice.h"

#include    "upnpavcontroller.h"

#include    "upnpavcontrollerfactory.h"

#include    "cmdmmain.h"

#include    "cmfillmanagerfactory.h"

#include    "cmfillmanager.h"

#include    "cmstoremanagerfactory.h"

#include    "cmstoremanager.h"

#include    "cmscheduler.h"

#include    "cmmmmain.h"

#include    "cmfilllistitem.h"

#include    "cmdriveinfo.h"

#include    "cmmediaserverfull.h"

#include    "cmfillrulecontainer.h"

#include    "cmfillrule.h"

#include    "cmsqlpropertycontainer.h"

#include    "cmsettingsfactory.h"

#include	"mmdhclient.h"

#include	"mdhclientfactory.h"

#include    "cmsettings.h"

#include    "cmserver.h"

#include    "cmserversession.h"

#include    "msdebug.h"

// CONSTANTS

const TInt KDefaultSystemUpdateId = 0;  // default system update id

const TInt KArrayGranularity = 16;      // array granularity

const TInt KDriveBufferSize = 4;        // drive letter buffer size

const TInt KDeleteDataBaseItem = 255;   // delete status for FillListId

_LIT( KColon, ":");                     // colon

_LIT( KDoubleBackSlash, "\\");          // double backslash

//Total number of ranges

const TUint KCmServerRangeCount = 2;

//Definition of the ranges of IPC numbers

const TInt KCmServerRanges[KCmServerRangeCount] =

        {

        0,

        34

        };

//Policy to implement for each of the above ranges

const TUint8 KCmServerElementsIndex[KCmServerRangeCount] =

        {

        1, //applies to 1st range

        CPolicyServer::ENotSupported

        };

//Specific capability checks

const CPolicyServer::TPolicyElement KCmServerElements[] =

        {

        {_INIT_SECURITY_POLICY_C3(ECapabilityNetworkServices,

            ECapabilityReadUserData, ECapabilityWriteUserData ),

            CPolicyServer::EFailClient },

        {_INIT_SECURITY_POLICY_C1(ECapabilityNetworkServices),

            CPolicyServer::EFailClient}

        };

//Package all the above together into a policy

const CPolicyServer::TPolicy KCmServerPolicy =

        {

        //specifies all connect attempts should pass

        CPolicyServer::EAlwaysPass,

        KCmServerRangeCount,

        KCmServerRanges,

        KCmServerElementsIndex,

        KCmServerElements

        };

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

// CCmServer::CCmServer

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

//

CCmServer::CCmServer()

    : CPolicyServer( CActive::EPriorityHigh, KCmServerPolicy )

    {

    LOG(_L("[Cm Server]\t CCmServer::CCmServer"));

    }

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

// CCmServer::ConstructL

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

//

void CCmServer::ConstructL()

    {

    LOG(_L("[Cm Server]\t CCmServer::ConstructL"));

    iServerState = ECmServerStateIdle;

    iSessionCount = (TInt*) User::AllocL( sizeof( TInt ) );

    *iSessionCount = 0;

    LOG(_L("[Cm Server]\t Creating settings.."));

    iSettings = CCmSettingsFactory::NewCmSettingsEngineL();

    TCmServiceState cmState( ECmServiceStateDisabled );

    iSettings->GetServiceState( ECmServiceContentManager, cmState );

    TRACE(Print(_L("[Cm Server]\t Cm state is %d\n"), cmState));

    if ( cmState )

        {

        LOG(_L("[Cm Server]\t Creating scheduler.."));

        iScheduler = CCmScheduler::NewL( *this, *iSettings );

        if ( cmState == ECmServiceStateAutomatic )

            {

            iScheduler->SetServiceToExecute( ECmServicePreProcessingStore );

            }

        }

    LOG(_L("[Cm Server]\t Creating db manager"));

    iDbManager = CCmDmMain::NewL();

    LOG(_L("[Cm Server]\t Creating Mde session"));

    iSession = CMdESession::NewL(*this);

    RPointerArray<CCmDriveInfo> drives;

    CleanupClosePushL( drives );

    iDbManager->PrepareQueryCmdL( EDrivesQuery );

    iDbManager->QueryDrivesL( drives );

    TRACE(Print(_L("[Cm Server]\t Drives count = %d"),

        drives.Count() ));

    if( drives.Count() )

        {

        SetDriveSelectionStatus( ETrue );

        }

    drives.ResetAndDestroy();

    CleanupStack::PopAndDestroy( &drives );

    LOG(_L("[Cm Server]\t Creating memory manager"));

    TBool mmEnabled( EFalse );

    iSettings->GetMemoryManagerStatus( mmEnabled );

    LOG(_L("[Cm Server]\t Creating memory manager"));

    iMemoryManager = CCmMmMain::NewL( *iDbManager );

    iMemoryManager->SetQuotaListenerStateL( mmEnabled );

    LOG(_L("[Cm Server]\t Creating store manager"));

    iStoreManager = CmStoreManagerFactory::NewStoreManagerL( this, *iSession,

        iDbManager, iMemoryManager);

    LOG(_L("[Cm Server]\t Creating fill manager"));

    iFillManager = CmFillManagerFactory::NewFillManagerL(

        this, *iSession, iDbManager, iMemoryManager);

    LOG(_L("[Cm Server]\t Starting server..."));

    StartL( KCmServerName );

    LOG(_L("[Cm Server]\t CCmServer::ConstructL end"));

    }

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

// CCmServer::NewLC

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

//

CCmServer* CCmServer::NewLC()

    {

    LOG(_L("[Cm Server]\t CCmServer::NewLC"));

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CCmServer::~CCmServer

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

//

CCmServer::~CCmServer()

    {

    LOG(_L("[Cm Server]\t CCmServer::~CCmServer"));

    delete iDeviceDiscoveryTimer;

    delete iFillRuleContainer;

    if ( iFillManager )

        {

        iFillManager->Close();

        }

    if ( iStoreManager )

        {

        iStoreManager->Close();

        }

    if ( iAvController )

        {

        iAvController->RemoveDeviceObserver();

		iAvController->Release();

		iAvController = NULL;

        }

    iMdhClient->Close();

    delete iPropertyContainer;

    delete iDbManager;

    delete iMemoryManager;

    delete iSessionCount;

    iSettings->Close();

    delete iSession;

    delete iScheduler;

    }

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

// CCmServer::NewSessionL

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

//

CSession2* CCmServer::NewSessionL( const TVersion& aVersion,

                                   const RMessage2 &/*aMessage*/) const

    {

    LOG(_L("[Cm Server]\t CCmServer::NewSessionL"));

    // check we're the right version

    TVersion version( KCmServerMajor,

                      KCmServerMinor,

                      KCmServerBuild);

    if( !User::QueryVersionSupported( version, aVersion ) )

        {

        LOG(_L("[Cm Server]\t CCmServer::NewSessionL leave with \

        KErrNotSupported"));

        User::Leave( KErrNotSupported );

        }

    ++(*iSessionCount);

    // make new session

    return CCmSession::NewL( *iDbManager, *iSettings );

    }

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

// CCmServer::CreateAvcAndTimerL

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

//

void CCmServer::CreateAvcAndTimerL()

    {

    LOG(_L("[Cm Server]\t CCmServer::CreateAvcAndTimerL"));

    iAvController = UPnPAVControllerFactory::NewUPnPAVControllerL();

    iAvController->SetDeviceObserver( *this );

    LOG( _L("[Cm Server]\t Creating CPeriodic timer..." ) );

    iDeviceDiscoveryTimer = CPeriodic::NewL(EPriorityHigh);

    TInt deviceDiscoveryDelay( 0 );

    iSettings->GetDiscoveryDelay( deviceDiscoveryDelay );

    TRACE(Print(_L("[Cm Server]\t using device discovery delay %d\n"),

        deviceDiscoveryDelay));

    iDeviceDiscoveryTimer->Start(deviceDiscoveryDelay * KMega,

                  0,

                  TCallBack(SearchTimerCompletedL,

                  this));

    LOG( _L("[Cm Server]\t Updated!" ) );

    iMediaServers.ResetAndDestroy();

    LOG( _L("[Cm Server]\t Loading media servers from db..." ) );

    iDbManager->GetMediaServersL( iMediaServers );

    }

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

// CCmServer::LeaveIfNotReadyL

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

//

void CCmServer::LeaveIfNotReadyL()

    {

    LOG(_L("[Cm Server]\t CCmServer::LeaveIfNotReadyL"));

    if ( ServerState() != ECmServerStateIdle )

        {

        if ( !ServerState() ) // CM disabled

            {

            LOG(_L("[Cm Server]\t CCmServer::LeaveIfNotReadyL \

            leave with KErrNotReady"));

            User::Leave( KErrNotReady );

            }

        // CM busy

        LOG(_L("[Cm Server]\t CCmServer::LeaveIfNotReadyL \

        leave with KErrServerBusy"));

        User::Leave( KErrServerBusy );

        }

    }

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

// CCmServer::DeleteUnselectedFillFilesL

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

//

void CCmServer::DeleteUnselectedFillFilesL()

    {

    LOG(_L("[Cm Server]\t CCmServer::DeleteUnselectedFillFilesL"));

    for ( ; iFillRuleIndex < iFillRuleContainer->FillRuleCount();

            iFillRuleIndex++ )

        {

        CCmFillRule* rule =

            iFillRuleContainer->FillRule( iFillRuleIndex );

        TCmFillRuleStatus status = rule->Selected();

        if ( status == ECmUnSelected || status == ECmDeleted )

        	{

        	iDeletingDeletedItems = ETrue;

        	DeleteFilledFilesL();

        	iFillRuleIndex = iFillRuleContainer->FillRuleCount();

        	}

        }

    if ( !iDeletingDeletedItems )

    	{

    	// no unselected lists - complete delete request

    	iDeletingDeletedItems = EFalse;

    	ServiceExecuted( ECmServiceDeleteFilledFiles, KErrNone );

    	}

    }

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

// CCmServer::DecrementSessions

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

//

void CCmServer::DecrementSessions()

    {

    LOG(_L("[Cm Server]\t CCmServer::DecrementSessions"));

    --( *iSessionCount );

    if ( (*iSessionCount) <= 0 )

        {

        TCmServiceState cmState;

        iSettings->GetServiceState( ECmServiceContentManager, cmState );

        TBool mmEnabled;

        iSettings->GetMemoryManagerStatus( mmEnabled );

        if ( !cmState && !mmEnabled &&

             ServerState() == ECmServerStateIdle )

             // cm & mm disabled and server idle

            {

            // shutdown server

            LOG(_L("[Cm Server]\t Server & mm disabled and \

                no sessions left, shutting down.."));

            CActiveScheduler::Stop();

            }

        }

    }

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

// CCmServer::ServerState

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

//

TCmServerState CCmServer::ServerState() const

    {

    TRACE( Print( _L("[Cm Server]\t CCmServer::ServerState \

    iServerState = %d"), iServerState ));

    return iServerState;

    }

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

// CCmServer::PropertyContainer

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

//

CCmSqlPropertyContainer* CCmServer::PropertyContainer() const

    {

    LOG(_L("[Cm Server]\t CCmServer::PropertyContainer"));

    return iPropertyContainer;

    }

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

// CCmServer::PropertyCollector

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

//

CCmSqlPropertyCollector* CCmServer::PropertyCollector() const

    {

    LOG(_L("[Cm Server]\t CCmServer::PropertyCollector"));

    return iPropertyCollector;

    }

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

// CCmServer::MediaServerArray

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

//

RPointerArray<CCmMediaServerFull>& CCmServer::MediaServerArray()

    {

    LOG(_L("[Cm Server]\t CCmServer::MediaServerArray"));

    return iMediaServers;

    }

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

// CCmServer::UpdateFillPriorities

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

//

void CCmServer::UpdateFillPriorities()

    {

    LOG(_L("[Cm Server]\t CCmServer::UpdateFillPriorities"));

    iFillManager->UpdatePriorities();

    }

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

// CCmServer::DeletePropertyContainer

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

//

void CCmServer::DeletePropertyContainer()

    {

    LOG(_L("[Cm Server]\t CCmServer::DeletePropertyContainer"));

    if ( iPropertyContainer )

        {

        delete iPropertyContainer;

        iPropertyContainer = NULL;

        }

    }

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

// CCmServer::DeleteItemsByFillListId

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

//

void CCmServer::DeleteItemsByFillListId( TInt aFillListId )

	{

    LOG(_L("[Cm Server]\t CCmServer::DeleteItemsByFillListId"));

    TInt error = iDbManager->DeleteItemsByFillListId( aFillListId );

    if ( error )

       	{

       	TRACE( Print( _L("[Cm Server]\t CCmServer::DeleteItemsByFillListId \

       	error = %d\n"), error ));

       	}

	}

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

// CCmServer::FillRuleContainerL

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

//

CCmFillRuleContainer* CCmServer::FillRuleContainerL() const

    {

    LOG(_L("[Cm Server]\t CCmServer::FillRuleContainerL"));

    RPointerArray<HBufC8> array;

    CleanupClosePushL( array );

    iDbManager->PrepareQueryCmdL( EFillRuleNamesQuery );

    iDbManager->QueryFillRuleNamesL( array );

    TRACE(Print(_L("[Cm Server]\t fill rule array size is %d"),

        array.Count()));

    CCmFillRuleContainer* ruleContainer = CCmFillRuleContainer::NewLC();

    for ( TInt i = 0; i < array.Count(); i++ )

        {

        CCmFillRule* rule = CCmFillRule::NewLC();

        rule->SetNameL( *(array[i]) );

        iDbManager->PrepareQueryCmdL( EFillRuleQuery );

        iDbManager->QueryFillRuleL( rule );

        ruleContainer->AddFillRuleL( rule );

        CleanupStack::Pop( rule );

        }

    CleanupStack::Pop( ruleContainer );

    array.ResetAndDestroy();

    CleanupStack::PopAndDestroy( &array );

    return ruleContainer;

    }

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

// CCmServer::ExecuteStoreL

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

//

void CCmServer::ExecuteStoreL()

    {

    LOG(_L("[Cm Server]\t CCmServer::ExecuteStoreL"));

    TInt err = KErrNone;

    iServerState = ECmServerStateStoring;

    if ( !iAvController ) // need to create avc and wait for devices

        {

        TRAP( err, CreateAvcAndTimerL() );

        TRACE(Print(_L("[Cm Server]\t CreateAvcAndTimerL err = %d"), err ));

        }

    else // avc already created, start store

        {

        iStoreManager->SetAvController( iAvController );

        TRAP( err, iStoreManager->StartStoreL() );

        }

    if ( err )

        {

        TRACE(Print(_L("[Cm Server]\t Error occurred = %d"), err ));

        ServiceExecuted( ECmServiceStore, err );

        }

    }

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

// CCmServer::ExecuteFillL

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

//

void CCmServer::ExecuteFillL()

    {

    LOG(_L("[Cm Server]\t CCmServer::ExecuteFillL"));

    if( !iDriveSelectionStatus )

        {

        LOG(_L("[Cm Server]\t No drives selected. Do not start fill!!!"));

        iServerState = ECmServerStateFilling;

        ServiceExecuted( ECmServiceFill, KErrNone );

        }

    else

        {

        TInt err = KErrNone;

        if ( !iAvController ) // need to create avc and wait for devices

            {

            TRAP( err, CreateAvcAndTimerL() );

            }

        else // avc already created, start fill

            {

            iSettings->GetMemoryManagerStatus( iMmState );