/** @file

* Copyright (c) 2005-2006 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:  Media Server

*

*/

// INCLUDE FILES

#include "upnpmediaserver.h"

#include "upnpcontentdirectoryservice.h"

#include "upnpmediaserversession.h"

#include "upnpmediaserverglobals.h"

#include "upnpcontentdirectoryglobals.h"

#include "upnpmediaserverclient.h"

#include "upnpsecuritymanager.h"

#include "upnpfiletransferevent.h"

#include <upnpdevicedescriptionstore.h>

#include "upnpdeviceimplementation.h"

#include "upnpcm.h"

#include "upnpiconmanager.h"

#include "upnpdiskremovedetector.h"

#include <sysutil.h>

#define KLogFile _L("upnpmediaserver.txt")

#include "upnpcustomlog.h"

#include <upnpconnectionmanagernetworkeventprovider.h>

#include "upnpmediaserverdescriptionprovider.h"

const TVersion KServerSupportedVersion(

    KMediaServerMajorVersionNumber,

    KMediaServerMinorVersionNumber,

    KMediaServerBuildVersionNumber );

using namespace UpnpMediaServerSettings;

_LIT8( KUriMediaServer, "/mediaserver1/mediaserver1.xml" );

_LIT8( KUriContentDirectory, "/mediaserver1/contentdirectory1.xml" );

_LIT8( KUriConnectionManager, "/mediaserver1/connectionmanager1.xml" );

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

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

// CUpnpMediaServer::CUpnpMediaServer

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

// might leave.

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

//

CUpnpMediaServer::CUpnpMediaServer():

    iMsStatus( RUpnpMediaServerClient::EStopped )

    {

    }

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

// CUpnpMediaServer::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CUpnpMediaServer::ConstructL()

    {

    BaseConstructL();

    iSettings = CUpnpMediaServerSettings::NewL();

    iDiskDetector = CUpnpDiskRemoveDetector::NewL( this );

    iStopAVMediaServerTimer = CUpnpNotifyTimer::NewL( this );

    iConnectionManagerNetworkEventProvider = 

        CUpnpConnectionManagerNetworkEventProvider::NewL( *this );

    iDescriptionProvider = CUpnpMediaServerDescriptionProvider::NewL();

    InitializeL( EFalse );

    iDescriptionStore = CUpnpDeviceDescriptionStore::NewL( *iMsName );

    iIconManager = CUpnpIconManager::NewL( *iDescriptionStore, *iDescriptionProvider );

    }

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

// CUpnpMediaServer::NewL

// Two-phased constructor.

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

//

CUpnpSymbianServerBase* CUpnpMediaServer::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// Destructor

CUpnpMediaServer::~CUpnpMediaServer()

    {

    if ( iDescriptionStore )

        {

        TRAP_IGNORE( iDescriptionStore->SaveL() );

        }

    ASSERT( CanBeStopped() );//check if we are in correct state

    delete iStopAVMediaServerTimer;

    delete iMsName;

    delete iCdName;

    delete iCmName;

    delete iConnectionManagerNetworkEventProvider;

    iObserverList.ResetAndDestroy();

    delete iSettings;

    delete iManager;

    delete iIconManager;

    delete iDevice;

    delete iDescriptionStore;

    delete iContentDirecory;

    delete iCm;

    delete iDiskDetector;

    delete iDescriptionProvider;

    }

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

// CUpnpMediaServer::StopAVMediaServer

//

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

//

void CUpnpMediaServer::StopAVMediaServer( TBool aSilent )

    {

    LOGS( "CUpnpMediaServer::StopAVMediaServer begin" );

    iIsSilentShutdown = aSilent;

    //ms will be stopped in KStopAVMediaServerDelay unless he gets start request

    iStopAVMediaServerTimer->Start( KStopAVMediaServerDelay );

    }

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

// CUpnpMediaServer::StopAVMediaServerImmediately

// Immediately stops media server ( no delay )

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

//

void CUpnpMediaServer::StopAVMediaServerImmediately( TBool aSilent, TBool aWlanLost )

    {

    iStopAVMediaServerTimer->Cancel();

    iDiskDetector->Cancel();

    delete iManager;

    iManager = NULL;

    // we do not want any stop devices in case of WLAN lost

    if ( !aWlanLost )

        {

        if ( iDevice )

            {

            if ( !aSilent )

                {

                TRAP_IGNORE( iDevice->StopL() );

                }

            else

                {

                TRAP_IGNORE( iDevice->StopL( CUpnpDeviceImplementation::EStopSilent ) );

                }

            }

        }

    delete iContentDirecory;

    iContentDirecory = NULL;

    delete iCm;

    iCm = NULL;

    delete iDevice;

    iDevice = NULL;

    SetStatus( RUpnpMediaServerClient::EStopped );

    SuggestShutdown();

    LOGS( "CUpnpMediaServer::StopAVMediaServer end" );

    }

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

// CUpnpMediaServer::NewSessionL

// Create new session.

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

//

CSession2* CUpnpMediaServer::NewSessionL( const RMessage2& /*aMessage*/ ) const

    {

    return CUpnpMediaServerSession::NewL( (CUpnpMediaServer*) this );

    }

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

// CUpnpMediaServer::Status

// Check status of the server.

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

//

RUpnpMediaServerClient::TServerStatus CUpnpMediaServer::Status() const

    {

    if ( iStopAVMediaServerTimer && iStopAVMediaServerTimer->IsActive() )

        {

        return RUpnpMediaServerClient::EStopped;

        }

    return iMsStatus;

    }

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

// CUpnpMediaServer::StartAVMediaServerL

// Create and start the AV Media Server.

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

//

void CUpnpMediaServer::StartAVMediaServerL()

    {

    LOGS( "CUpnpMediaServer::StartAVMediaServerL begin" );

    // cleanup because previous start could fail

    StopAVMediaServerImmediately( EFalse, EFalse );

    // save description

    iDescriptionStore->SaveL();

    // create device

    iDevice = CUpnpDeviceImplementation::NewL( KUriMediaServer, 

                                               *iDescriptionStore, 

                                               *iDescriptionProvider );

    // create security manager

    iManager = CUpnpSecurityManager::NewInstanceFromUpnpSettingsL();

    //iDevice->SetSecurityManager( iManager );

    // create content direcory service

    HBufC8* uploadtmp = iSettings->GetL( EUploadDirectory );

    CleanupStack::PushL( uploadtmp );

    if ( uploadtmp->Length() == 0 )

        {

        User::Leave( KErrNotReady );

        }

    HBufC* uploaddir = HBufC::NewL( uploadtmp->Length() );

    CleanupStack::PushL( uploaddir );

    uploaddir->Des().Copy( uploadtmp->Des() );

    HBufC* thumbnaildir = HBufC::NewL( uploaddir->Length()

            + KThumbnailDirLen );

    CleanupStack::PushL( thumbnaildir );

    thumbnaildir->Des().Copy( uploaddir->Des() );

    thumbnaildir->Des().Append( KThumbnailSubDir );

    TInt createThumbnails;

    User::LeaveIfError( iSettings->Get( EUpnpMediaServerThumbnails,

        createThumbnails ) );

    TInt maxReqCount;

    User::LeaveIfError( iSettings->Get( KUpnpMediaServerBrowseLimit,

        maxReqCount ) );

    TUpnpCdSettings cdset =

        {

        iDevice, *uploaddir, *thumbnaildir, *iCdName, NULL, createThumbnails,

                maxReqCount, this, KNullDesC(), NULL

        };

    iContentDirecory = CUpnpContentDirectoryService::NewL( cdset );

    // create connection manager service

    HBufC8* media = iSettings->GetL( ESupportedMedia );

    CleanupStack::PushL( media );

    if ( media->Length() == 0 )

        {

        User::Leave( KErrNotReady );

        }

    iCm = CUpnpCM::NewL( *iDevice, *media, *iCmName );

    CleanupStack::PopAndDestroy( media );

    CleanupStack::PopAndDestroy( thumbnaildir );

    CleanupStack::PopAndDestroy( uploaddir );

    CleanupStack::PopAndDestroy( uploadtmp );

    SetDescriptionSettingsL( iDevice );

    // start media server

    iDevice->StartL();

    iDiskDetector->StartL();

    SetStatus( RUpnpMediaServerClient::EStartedOnline );

    LOGS( "CUpnpMediaServer::StartAVMediaServerL end" );

    }

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

// CUpnpMediaServer::StartAVMediaServerOfflineL

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

//

void CUpnpMediaServer::StartAVMediaServerOfflineL()

    {

    LOGS( "StartAVMediaServerOfflineL begin" );

    // cleanup because previous start could fail

    StopAVMediaServerImmediately( EFalse, EFalse );

    // create content directory

    iContentDirecory = CUpnpContentDirectoryService::NewL();

    SetStatus( RUpnpMediaServerClient::EStartedOffline );

    LOGS( "StartAVMediaServerOfflineL end" );

    }

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

// CUpnpMediaServer::RestartAVMediaServerL

// Start and stop the AV Media Server.

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

//

void CUpnpMediaServer::RestartAVMediaServerL()

    {

    if ( iDevice )

        {

        iDevice->StopL();

        SetDescriptionSettingsL( iDevice );

        iDevice->StartL();

        }

    }

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

// CUpnpMediaServer::SetFriendlyNameL

// Sets friendly name for device, changes are available after restarting

// the server

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

//

void CUpnpMediaServer::SetDescriptionSettingsL(

    CUpnpDeviceImplementation* aDevice )

    {

    SetDescriptionRequiredPropertyL( aDevice, EFriendlyName, KFriendlyName );

    SetDescriptionRequiredPropertyL( aDevice, EModelName, KModelName );

    SetDescriptionRequiredPropertyL( aDevice, EManufacturer, KManufacturer );

    SetDescriptionPropertyL( aDevice, EModelUrl, KModelUrl );

    SetDescriptionPropertyL( aDevice, EModelDescription, KModelDescription );

    SetDescriptionPropertyL( aDevice, EModelNumber, KModelNumber );

    SetDescriptionPropertyL( aDevice, ESerialNumber, KSerialNumber );

    SetDescriptionPropertyL( aDevice, EPresentationUrl, KPresentationUrl );

    SetDescriptionPropertyL( aDevice, EManufacturerUrl, KManufacturerUrl );

    }

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

// CUpnpMediaServer::RemoveIconL

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

//

void CUpnpMediaServer::RemoveIconL( const TDesC8& aUrl )

    {

    iIconManager->RemoveIconL( aUrl );

    }

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

// CUpnpMediaServer::RemoveIconsL

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

//

void CUpnpMediaServer::RemoveIconsL()

    {

    iIconManager->RemoveIconsL();

    }

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

// CUpnpMediaServer::AddIconL

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

//

void CUpnpMediaServer::AddIconL( const TDesC8& aProperty )

    {

    iIconManager->AddIconL( aProperty );

    }

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

// CUpnpMediaServer::UpdateIconL

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

//

void CUpnpMediaServer::UpdateIconL( const TDesC8& aProperty,

    const TDesC8& aUrl )

    {

    iIconManager->UpdateIconL( aProperty, aUrl );

    }

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

// CUpnpMediaServer::SetUploadDirToCDL

// Set the download and thumbnail in CD according to the value

// of the upload directory

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

//

void CUpnpMediaServer::SetUploadDirToCDL( const TDesC& aPath )

    {

    if ( iContentDirecory )

        {

        HBufC* uploaddir= NULL;

        if ( aPath != KNullDesC() )

            {

            uploaddir = aPath.AllocLC();

            }

        else

            {

            HBufC8* uploadtmp = iSettings->GetL( EUploadDirectory );

            CleanupStack::PushL( uploadtmp );

            uploaddir = HBufC::NewL( uploadtmp->Length() );

            uploaddir->Des().Copy( uploadtmp->Des() );

            CleanupStack::PopAndDestroy( uploadtmp );

            CleanupStack::PushL( uploaddir );

            }

        HBufC* thumbnaildir = HBufC::NewL( uploaddir->Length()

                + KThumbnailDirLen );

        CleanupStack::PushL( thumbnaildir );

        thumbnaildir->Des().Copy( uploaddir->Des() );

        thumbnaildir->Des().Append( KThumbnailSubDir );

        iContentDirecory->SetDownloadDirectoryL( uploaddir->Des() );

        iContentDirecory->SetThumbnailDirectoryL( thumbnaildir->Des() );

        CleanupStack::PopAndDestroy( thumbnaildir );

        CleanupStack::PopAndDestroy( uploaddir );

        }

    }

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

// CUpnpMediaServer::SetUploadDirL

// Set the upload and thumbnail path in CD and central repository.

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

//

void CUpnpMediaServer::SetUploadDirL( const TDesC& aPath )

    {

    User::LeaveIfError( iSettings->Set(

        UpnpMediaServerSettings::EUploadDirectory, aPath ) ) ;

    SetUploadDirToCDL( KNullDesC( )); // empty descriptor -> it means, value will be taken directly from cenrep

    }

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

// CUpnpMediaServer::SetDescriptionPropertyL

// Sets description property for device

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

//

void CUpnpMediaServer::SetDescriptionPropertyL(

    CUpnpDeviceImplementation* aDevice, TInt aKey, const TDesC8& aName )

    {

    HBufC8* value = iSettings->GetL( aKey );

    CleanupStack::PushL( value );

    if ( value->Size() )

        {

        aDevice->SetDescriptionPropertyL( aName, *value );

        }

    else

        {

        aDevice->RemoveDescriptionPropertyL( aName );

        }

    CleanupStack::PopAndDestroy( value );

    }

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

// CUpnpMediaServer::SetDescriptionRequiredPropertyL

// Sets description required property for device

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

//

void CUpnpMediaServer::SetDescriptionRequiredPropertyL(

    CUpnpDeviceImplementation* aDevice, TInt aKey, const TDesC8& aName )

    {

    HBufC8* value = iSettings->GetL( aKey );

    if ( !value )

        {

        User::Leave( KErrNotFound );

        }

    else

        {

        CleanupStack::PushL( value );

        HBufC8* tmpBuf = (*value).AllocLC();

        TPtr8 tmpPtr(tmpBuf->Des() );

        RemoveWhiteSpaces( tmpPtr );

        if ( tmpPtr.Length() == 0 )

            {

            User::Leave( KErrNotFound );

            }

        CleanupStack::PopAndDestroy( tmpBuf );

        }

    TRAPD( error, aDevice->SetDescriptionPropertyL( aName, *value ) )

    if ( error != KErrNotFound )

        {

        User::LeaveIfError( error );

        }

    CleanupStack::PopAndDestroy( value );

    }

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

// CUpnpMediaServer::RemoveWhiteSpaces

// Removes white characters from input descriptor

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

//

void CUpnpMediaServer::RemoveWhiteSpaces( TDes8& aString )

    {

    for ( TInt i=0; i<aString.Length(); i++ )

        {

        if ( aString[i] == ' ' || aString[i] == '\r' || aString[i] == '\n'

                || aString[i] == '\t' )

            {

            aString.Replace( i, 1, KNullDesC8() );

            i--;

            }

        }

    }

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

// CUpnpMediaServer::InitPrivateDir

// Init Media Server directory structure in private directory

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

//

void CUpnpMediaServer::InitPrivateDirL( RFs &aFs )

    {

    TParse fp;

    TFileName path;

    aFs.PrivatePath( path );

    fp.Set( KDefaultMediaDrive(), &path, 0 );

    User::LeaveIfError( fp.AddDir( KMSPublicAccessedDir() ) );

    User::LeaveIfError( fp.AddDir( KMSDeviceXmlDescDir() ) );

    User::LeaveIfError( fp.AddDir( KIconDirectory() ) );

    path = fp.DriveAndPath();

    aFs.MkDirAll( path ) ;