/*

* Copyright (c) 2007 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:      Metadata Harvester server's mediaserver container component

*

*/

// INCLUDE FILES

#include    <e32property.h>

#include    <f32file.h>

#include    "cmsettingsfactory.h"

#include    "cmsettings.h"

#include    "cmdmmain.h"

#include    "cmmediaserverfull.h"

#include    "cmsearchresponsehash.h"

#include    "cmsettings.h"

#include    <upnpstring.h>

#include    <upnperrors.h>

#include    "mdhconnectionmonitor.h"

#include    "mdhmediaservercontainer.h"

#include    "mdhmetadatacollector.h"

#include    "mdhserver.h"

#include    "msdebug.h"

// CONSTANTS

#ifdef __SERIES60_31__

_LIT8( KAVControlPointFriendlyName,  "AVDevice" );

#endif //__SERIES60_31__

_LIT8( KMediaServer,                 "MediaServer" );

#ifdef _DEBUG

_LIT8( KFriendlyNameTag,             "friendlyName" );

#endif

const TInt KDefaultCaculateSize = 100;

const TInt KDefaultChunkSize = 150;

const TInt KDefaultAddGranularity = 500;

// amount of microseconds in one second

const TInt KMicrosecondsInSecond = 1000000;

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

// Two-phase API constructor

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

// 

CCmMdhMediaserverInfo* CCmMdhMediaserverInfo::NewL( )

    {  

    CCmMdhMediaserverInfo* self = CCmMdhMediaserverInfo::NewLC( );

    CleanupStack::Pop( self );

    return self;

    }

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

// Two-phase API constructor

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

//     

CCmMdhMediaserverInfo* CCmMdhMediaserverInfo::NewLC()

    {   

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

    CleanupStack::PushL( self );

    self->ConstructL( );    

    return self;  

    }    

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

// Destructor

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

// 

CCmMdhMediaserverInfo::~CCmMdhMediaserverInfo()

    {

    delete iUuid;

    }

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

// C++ default constructor

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

//            

CCmMdhMediaserverInfo::CCmMdhMediaserverInfo( )

    {

    }

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

// ConstructL

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

//  

void CCmMdhMediaserverInfo::ConstructL( )

    {

    } 

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

// Two-phased constructor.

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

CCmMdhMediaserverContainer* CCmMdhMediaserverContainer::NewL(

    CCmMdhServer& aMdhServer)

    {

    LOG(_L("[CmMdh Server]\t CCmMdhMediaserverContainer::NewL"));

    CCmMdhMediaserverContainer* self =

        new (ELeave) CCmMdhMediaserverContainer(aMdhServer);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Constructor.

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

CCmMdhMediaserverContainer::CCmMdhMediaserverContainer(

    CCmMdhServer& aMdhServer)

    :iMdhServer( aMdhServer )

    {

    LOG(_L("[CmMdh Server]\t CCmMdhMediaserverContainer::\

                             CCmMdhMediaserverContainer"));

    iAvControlPoint = NULL;

    iMetadataCollector = NULL;

    iTimer = NULL;

    iMediaserverIndex = 0;

    iResponsesPending = 0;

    iTotalItemCount = 0;

    iHarvestErrCode = KErrNone;

    iHarvestActive = EFalse;

    iPropertyItemIndex = 0;

    iProgressInfo.iService = ECmServiceHarvest;

    }

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

// 2nd phase constructor.

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

void CCmMdhMediaserverContainer::ConstructL()

    {

    LOG(_L("[CmMdh Server]\t CCmMdhMediaserverContainer::ConstructL"));

    iDbManager = CCmDmMain::NewL();

    iSettings = CCmSettingsFactory::NewCmSettingsEngineL();

    iSettings->GetIapL( iIap );

    TRACE( Print( _L("[CmMdh Server]\t Monitoring iap %d"), iIap ));

    iMdHConMon = CMdHConnectionMonitor::NewL( *this, iIap );

    }

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

// Destructor.

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

CCmMdhMediaserverContainer::~CCmMdhMediaserverContainer()

    {

    LOG(_L("[CmMdh Server]\t CCmMdhMediaserverContainer::\

                             ~CCmMdhMediaserverContainer"));

    TRACE( Print( _L("[CmMdh Server]\t deleting %d media servers"),

        iMediaservers.Count()));

    iMediaservers.ResetAndDestroy();

    iOldMediaServers.ResetAndDestroy();

    LOG(_L("[CmMdh Server]\t deleting settings engine.."));

	if ( iSettings )

	    {

	    iSettings->Close();    

	    }

    LOG(_L("[CmMdh Server]\t deleting db manager.."));

    if ( iDbManager )

        {

        delete iDbManager;    

        }    

    LOG(_L("[CmMdh Server]\t deleting metadata collector.."));

    if ( iMetadataCollector )

        {

        delete iMetadataCollector;

        }

    LOG(_L("[CmMdh Server]\t deleting av control point.."));

    if ( iAvControlPoint )

        {

        delete iAvControlPoint;    

        }

    LOG(_L("[CmMdh Server]\t deleting timer.."));

    if ( iTimer )

        {

        delete iTimer;    

        }

    LOG(_L("[CmMdh Server]\t deleting connection monitor.."));

    if ( iMdHConMon )

        {

        delete iMdHConMon;    

        }

    LOG(_L("[CmMdh Server]\t All deleted.."));

    }

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

// Harvest a media server

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

void CCmMdhMediaserverContainer::DoHarvestMediaserverL(

    TInt aMediaserverIndex )

    {

    LOG(_L("[CmMdh Server]\t CCmMdhMediaserverContainer::\

                             DoHarvestMediaserverL"));

    iMdhServer.SetServerStateL(ECmMdhServerStateHarvesting);

    if ( iMediaservers[aMediaserverIndex]->iMediaserverState

        == ECmMdhMediaserverNotSynchronized)

        {

        iMetadataCollector->HarvestMediaserverL(

            *iMediaservers[aMediaserverIndex]->iUuid );

        iHarvestActive = ETrue;

        }

    else

        {

        LOG(_L("[CmMdh Server]\t No search caps or \

                                 no sync needed, skipping.."));

        HarvestCompleteL( KErrNone );

        }

    LOG(_L("[CmMdh Server]\t CCmMdhMediaserverContainer::\

                             DoHarvestMediaserverL end"));

    }

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

// Adds a media server to database if it doesn't exist there

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

TBool CCmMdhMediaserverContainer::AddToDbIfNewL( CUpnpDevice& aMediaserver )

    {

    LOG(_L("[CmMdh Server]\t CCmMdhMediaserverContainer::AddToDbIfNewL"));

    CCmMediaServerFull* tempServer = CCmMediaServerFull::NewLC();

    tempServer->SetUDNL( aMediaserver.Uuid() );

    iDbManager->PrepareQueryCmdL( EMediaServerInfoQyery );

    TInt errCode = iDbManager->QueryMediaServerL( tempServer );

    TBool ret = EFalse;

    if ( errCode != KErrNotFound )

        {

        TRACE( Print( _L("[CmMdh Server]\t FillUsage: %d"),

        		tempServer->FillUsage()));

        ret = (TBool)tempServer->FillUsage();

        iAllFound = ETrue;

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

            {

            if( KErrNotFound != aMediaserver.Uuid().Match(

                iOldMediaServers[i]->MediaServer() ) )

                {

                TRACE( Print( _L("[CmMdh Server]\t In db...")));

                iOldMediaServers[i]->SetFillUsage( EFalse );

                }

            if( iOldMediaServers[i]->FillUsage())

                {

                TRACE( Print( _L("[CmMdh Server]\t All not found")));

                iAllFound = EFalse;

                }

            }

        }

    CleanupStack::PopAndDestroy( tempServer );

    return ret;

    }

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

// Decreases pending responses counter and finishes search if ready

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

void CCmMdhMediaserverContainer::DecResponsesAndFinishIfReadyL()

    {

    LOG(_L("[CmMdh Server]\t CCmMdhMediaserverContainer::\

                             DecResponsesAndFinishIfReadyL"));

    if ( !(--iResponsesPending )  )

        {

        if( iAllFound )

	        {

	        DoSearchTimerCompletedL();	

	        }

        }

    }

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

// Static timer callback function.

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

TInt CCmMdhMediaserverContainer::SearchTimerCompletedL( TAny* aInstance )

    {

    LOG(_L("[CmMdh Server]\t CCmMdhMediaserverContainer::\

                             SearchTimerCompleted"));

    return ((CCmMdhMediaserverContainer*)aInstance)

        ->DoSearchTimerCompletedL();

   }

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

// Timer callback function.

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

TInt CCmMdhMediaserverContainer::DoSearchTimerCompletedL()

    {

    LOG(_L("[CmMdh Server]\t CCmMdhMediaserverContainer::\

        DoSearchTimerCompleted"));

    delete iTimer;

    iTimer = NULL;

    TRACE( Print( _L("[CmMdh Server]\t Found %d media servers"),

        iMediaservers.Count()));

    if ( !iResponsesPending )

        {

        iOldMediaServers.ResetAndDestroy();

        iMdhServer.SetServerStateL(ECmMdhServerStateIdle);

        }

    return KErrNone;

   }

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

// Handles UPnP device discoveries.

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

void CCmMdhMediaserverContainer::DeviceDiscoveredL( CUpnpDevice* aDevice )

    {

    LOG(_L("[CmMdh Server]\t CCmMdhMediaserverContainer::DeviceDiscoveredL"));

#ifdef _DEBUG

    HBufC* uuid = UpnpString::ToUnicodeL( aDevice->Uuid() );

    HBufC* name = UpnpString::ToUnicodeL(

                    aDevice->DescriptionProperty( KFriendlyNameTag() ));

    HBufC* type = UpnpString::ToUnicodeL( aDevice->DeviceType() );

    TRACE( Print(_L("[CmMdh Server]\t type: %S uuid: %S, name %S"),

        type, uuid, name ));

    delete uuid;

    delete name;

    delete type;

#endif

    if (!iTimer) // search is no more active

        {

        LOG(_L("[CmMdh Server]\t Search no more active, returning.."));

        return;

        }

    if( aDevice->DeviceType().Find(KMediaServer) != KErrNotFound && 

        !iAllFound )

        {

        LOG(_L("[CmMdh Server]\t Found a media server"));

        if ( AddToDbIfNewL( *aDevice ) )

            {

            ++iResponsesPending;

            iAvControlPoint->CdsSearchCapabilitiesActionL( aDevice->Uuid() );

            }

#ifdef _DEBUG

        else

            {

            LOG(_L("[CmMdh Server]\t not active, skipping.."));

            }

#endif

        }

    }

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

// Handles UPnP device disappears.

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

void CCmMdhMediaserverContainer::DeviceDisappearedL(

    CUpnpDevice* /* aDevice */ )

    {

    LOG( _L("[CmMdh Server]\t CCmMdhMediaserverContainer::\

             DeviceDisappearedL") );

    }

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

// Searches UPnP Media servers.

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

void CCmMdhMediaserverContainer::SearchMediaserversL()

    {

    LOG(_L("[CmMdh Server]\t CCmMdhMediaserverContainer::\

                             SearchMediaServersL"));

    iResponsesPending = 0;

    iProgressInfo.iTotalItems = 0;

    iProgressInfo.iProcessedItems = 0;

    if ( !iAvControlPoint )

        {

        iSettings->GetIapL( iIap );

        // Create and start (automatic) the AV control point

        TRACE( Print( _L("[CmMdh Server]\t IAP to use is  %d"), iIap));

        LOG( _L("[CmMdh Server]\t Creating AV control point..." ) );

        iAvControlPoint = CUpnpAVControlPoint::NewL( *this );

        }

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

    iTimer = CPeriodic::NewL(EPriorityHigh);

    TInt deviceDiscoveryDelay;

    iSettings->GetDiscoveryDelay( deviceDiscoveryDelay );

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

        deviceDiscoveryDelay));

    iTimer->Start(deviceDiscoveryDelay * KMicrosecondsInSecond,

                  0,

                  TCallBack(SearchTimerCompletedL, this));

    iMdhServer.SetServerStateL(ECmMdhServerStateSearching);

    iOldMediaServers.ResetAndDestroy();

    iDbManager->GetMediaServersL( iOldMediaServers );

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

        {

        if ( !iOldMediaServers[i]->FillUsage() &&

             iOldMediaServers[i]->SystemUpdateID() != KErrNotFound )

            {

            iOldMediaServers[i]->SetSystemUpdateID( KErrNotFound );

            iDbManager->UpdateMediaServerInfo( iOldMediaServers[i] );

            }

        }

    iAllFound = EFalse;

    SendProgressInfo ( 0 );

    }

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

// Harvests media servers

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

void CCmMdhMediaserverContainer::HarvestMediaserversL()

    {

    LOG(_L("[CmMdh Server]\t CCmMdhMediaserverContainer::\

                             HarvestMediaserversL"));

    if ( !iAvControlPoint )

        {

        User::Leave( KErrNotReady );

        }

    if ( !iMediaservers.Count() )

        {

        User::Leave( KErrNotFound );

        }

    TBool harvestNeeded = EFalse;

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

        {

        if (iMediaservers[i]->iMediaserverState

            == ECmMdhMediaserverNotSynchronized )

            {

            harvestNeeded = ETrue;

            i = iMediaservers.Count(); // break from the loop

            }

        }

    if ( !harvestNeeded )

        {

        User::Leave( KErrAlreadyExists );

        }

    if ( !iMetadataCollector )

        {

        LOG( _L("[CmMdh Server]\t Creating metadata collector.." ) );

        TInt searchCount = KDefaultChunkSize;

        TInt addGranularity = KDefaultAddGranularity;

        iSettings->GetSearchCount( searchCount );

        iSettings->GetAddCount( addGranularity );

        TRACE( Print(

            _L("[CmMdh Server]\t using chunk size %d and addgran %d"),

            searchCount, addGranularity));

        iMetadataCollector =

            CCmMdhMetadataCollector::NewL(

                *this, *iAvControlPoint, searchCount, addGranularity );

        }

    iMediaserverIndex = 0;

    iHarvestErrCode = KErrNone;

    DoHarvestMediaserverL( iMediaserverIndex );

    LOG(_L("[CmMdh Server]\t CCmMdhMediaserverContainer::\

                             HarvestMediaserversL end"));

    }

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

// Harvest completion callback function

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

void CCmMdhMediaserverContainer::HarvestCompleteL( TInt aErr )

    {

    LOG(_L("[CmMdh Server]\t CCmMdhMediaserverContainer::HarvestComplete"));

    iHarvestActive = EFalse;

    if ( aErr != KErrNone )

        {

        iHarvestErrCode = aErr;

        }

    else

        {

        TInt newUpdateId =

            iMediaservers[iMediaserverIndex]->iSystemUpdateId;

        if ( newUpdateId ) // was set to 0 if no update needed

            {

            // store changed systemupdateid

            CCmMediaServerFull* tempServer = CCmMediaServerFull::NewLC();

            tempServer->SetUDNL(

                *(iMediaservers[iMediaserverIndex]->iUuid) );

            iDbManager->PrepareQueryCmdL( EMediaServerInfoQyery );

            TInt errCode = iDbManager->QueryMediaServerL( tempServer );

            if ( errCode != KErrNotFound )

                {

                TRACE( Print( _L

                    ("[CmMdh Server]\t Updating systemupdateid to %d.."),

                    newUpdateId ));

                tempServer->SetSystemUpdateID( newUpdateId );

                iDbManager->UpdateMediaServerInfo( tempServer );

                }

            CleanupStack::PopAndDestroy( tempServer );

            }

        }

    if ( ++iMediaserverIndex < iMediaservers.Count() )