/** @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 Session

*

*/

// INCLUDE FILES

#include "upnpmediaserversession.h"

#include "upnpmediaservereventhandler.h"

#include "upnpmediaserver.pan"

#include "upnpitem.h"

#include "upnpicon.h"

#include "upnpcontainer.h"

#include "upnpitemlist.h"

#include "upnpcontainerlist.h"

#include "upnpbrowsecriteria.h"

#include "upnpmediaserverclient.h"

#include <xml/xmlparsererrors.h>

#include <s32mem.h>

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

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

// CUpnpMediaServerSession::CUpnpMediaServerSession

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

//

CUpnpMediaServerSession::CUpnpMediaServerSession(CUpnpMediaServer* aServer)

    : CSession2(), iRespLengthPkg(iRespLength), iRespExecStatusPkg(iRespExecStatus)

    {

    iMediaServer = aServer;

    }

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

// CUpnpMediaServerSession::ConstructL

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

//

void CUpnpMediaServerSession::ConstructL()

    {

    iEventHandler = CUpnpMediaServerEventHandler::NewL(this->iMediaServer);

    }

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

// CUpnpMediaServerSession::~CUpnpMediaServerSession

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

//

CUpnpMediaServerSession::~CUpnpMediaServerSession()

    {

    delete iResponseBuffer;

    delete iEventHandler;

    }

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

// CUpnpMediaServerSession::ServiceL

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

//

void CUpnpMediaServerSession::ServiceL( const RMessage2& aMessage )

    {

    // first of all server must be started

    if( iMediaServer->Status() == RUpnpMediaServerClient::EStopped &&

        aMessage.Function() != EMediaServerStatus &&

        aMessage.Function() != EMediaServerStart &&

        aMessage.Function() != EMediaServerStartOffline &&

        aMessage.Function() != EMediaServerSubscribeEvents &&

        aMessage.Function() != EMediaServerUnsubscribeEvents &&

        aMessage.Function() != EMediaServerListenTransferEvent &&

        aMessage.Function() != EMediaServerGetTransferEventBody &&

        aMessage.Function() != EMediaServerStatusChange &&

        aMessage.Function() != EMediaServerStatusChangeCancel &&

        aMessage.Function() != EMediaServerAddIcon &&

        aMessage.Function() != EMediaServerRemoveIcon &&

        aMessage.Function() != EMediaServerRemoveIcons &&

        aMessage.Function() != EMediaServerUpdateIcon

        )

        {

        User::Leave( KErrNotReady );

        }

    switch ( aMessage.Function() )

        {

        case EMediaServerStatus:

            EventMediaServerStatusL( aMessage );

            break;

        case EMediaServerStartOffline:

            EventMediaServerStartOfflineL(aMessage);

            break;

        case EMediaServerStart:

            EventMediaServerStartL( aMessage );

            break;

        case EMediaServerStop:

            EventMediaServerStop( aMessage );

            break;

        case EMediaServerStopSilent:

            EventMediaServerStopSilent( aMessage );

            break;

        case EMediaServerRestart:

            EventMediaServerRestartL( aMessage );

            break;

        case EMediaServerShareItem:

            EventMediaServerShareItemL( aMessage );

            break;

        case EMediaServerShareItemResult:

            EventMediaServerGetShareItemResultL( aMessage );

            break;

        case EMediaServerShareContainer:

            EventMediaServerShareContainerL( aMessage );

            break;

        case EMediaServerShareContainerResult:

            EventMediaServerGetShareContainerResultL(aMessage);

            break;

        case EMediaServerShareItemList:

            EventMediaServerShareItemListL( aMessage );

            break;

        case EMediaServerShareItemListResult:

            EventMediaServerGetShareItemListResultL( aMessage );

            break;

        case EMediaServerUnshareItem:

            EventMediaServerUnshareItemL( aMessage );

            break;

        case EMediaServerUnshareRoot:

            EventMediaServerUnshareRootL( aMessage );

            break;

        case EMediaServerUnshareContainer:

            EventMediaServerUnshareContainerL( aMessage );

            break;

        case EMediaServerGetSharedItem:

            EventMediaServerGetSharedItemL( aMessage );

            break;

        case EMediaServerGetSharedItemResult:

            EventMediaServerGetGetSharedItemResultL( aMessage );

            break;

        case EMediaServerGetSharedContainer:

            EventMediaServerGetSharedContainerL( aMessage );

            break;

        case EMediaServerGetSharedContainerResult:

            EventMediaServerGetGetSharedContainerResultL( aMessage );

            break;

        case EMediaServerUnshareItemList:

            EventMediaServerUnshareItemListL( aMessage );

            break;

        case EMediaServerGetSharedItemList:

            EventMediaServerGetSharedItemListL(aMessage);

            break;

        case EMediaServerGetSharedItemListResult:

            EventMediaServerGetGetSharedItemListResultL(aMessage);

            break;

        case EMediaServerGetSharedContainerList:

            EventMediaServerGetSharedContainerListL(aMessage);

            break;

        case EMediaServerGetSharedContainerListResult:

            EventMediaServerGetGetSharedContainerListResultL(aMessage);

            break;

        case EMediaServerSubscribeEvents:

            iEventHandler->EventMediaServerSubscribeEvents(aMessage);

            break;

        case EMediaServerUnsubscribeEvents:

            iEventHandler->EventMediaServerUnsubscribeEvents(aMessage);

            break;

        case EMediaServerListenTransferEvent:

            iEventHandler->EventMediaServerServerListenTransferEventL(aMessage);

            break;

        case EMediaServerGetTransferEventBody:

            iEventHandler->EventMediaServerGetTransferEventBodyL(aMessage);

            break;

        case EMediaServerGetIpAndPort:

            EventMediaServerGetIpAndPortL(aMessage);

            break;

        case EMediaServerSetUploadDirectory:

            EventSetUploadDirectoryL( aMessage );

            break;

        case EMediaServerAddIcon:

            EventAddIconL( aMessage );

            break;

        case EMediaServerRemoveIcon:

            EventRemoveIconL( aMessage );

            break;

        case EMediaServerRemoveIcons:

            EventRemoveIconsL( aMessage );

            break;

        case EMediaServerUpdateIcon:

            EventUpdateIconL( aMessage );

            break;

        case EMediaServerShareReference:

            EventMediaServerShareReferenceL( aMessage );

            break;

        case EMediaServerShareReferenceList:

            EventMediaServerShareReferenceListL( aMessage );

            break;

        case EMediaServerStatusChange:

            EventMediaServerStatusChange( aMessage );

            break;   

        case EMediaServerStatusChangeCancel:

            EventMediaServerStatusChangeCancel( aMessage );

            break;    

        default :

            PanicClient( aMessage, EMediaServerBadRequest );

            break;

        }

    }

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

// CUpnpMediaServerSession::PanicClient

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

//

void CUpnpMediaServerSession::PanicClient( const RMessage2 &aMessage, TInt aPanic ) const

    {

    static_cast<const CUpnpSymbianServerBase*>(  Server() )->PanicClient( aMessage, aPanic );

    }

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

// CUpnpMediaServerSession::NewL

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

//

CUpnpMediaServerSession* CUpnpMediaServerSession::NewL(CUpnpMediaServer* aServer)

    {

    CUpnpMediaServerSession* self = CUpnpMediaServerSession::NewLC(aServer);

    CleanupStack::Pop( self ) ;

    return self ;

    }

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

// CUpnpMediaServerSession::NewLC

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

//

CUpnpMediaServerSession* CUpnpMediaServerSession::NewLC(CUpnpMediaServer* aServer)

    {

    CUpnpMediaServerSession* self = new (ELeave) CUpnpMediaServerSession(aServer);

    CleanupStack::PushL( self );

    self->ConstructL() ;

    return self ;

    }

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

// CUpnpMediaServerSession::EventMediaServerStartL

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

//

void CUpnpMediaServerSession::EventMediaServerStatusL( const RMessage2& aMessage )

    {

    TPckgBuf<TInt> status( iMediaServer->Status() );

    aMessage.WriteL( 0, status );

    aMessage.Complete( KErrNone );

    }

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

// CUpnpMediaServerSession::EventMediaServerStartL

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

//

void CUpnpMediaServerSession::EventMediaServerStartL( const RMessage2& aMessage )

    {

    iMediaServer->CancelAVMediaServerStop();//if stop was scheduled - cancel it

    if ( iMediaServer->Status() != RUpnpMediaServerClient::EStartedOnline )

        {

        TRAPD( err, iMediaServer->StartAVMediaServerL() );

        if ( err == KErrNotFound // files not found

            || err == KErrArgument // empty or improper one of description files

            || (err >= EXmlParserError && err <= EXmlFeatureLockedWhileParsing) // description malformed

            || err == KErrNoMemory // problem with start because of memory usage

            )

            {

            iMediaServer->InitializeL( ETrue );

            iMediaServer->RestartAVMediaServerL();

            iMediaServer->StartAVMediaServerL();

            }

        else if (err == KErrCorrupt || err == KErrEof || err == KErrNotSupported)

            {

            iMediaServer->ResetDbL();

            iMediaServer->StartAVMediaServerL();

            }

        else

            {

            User::LeaveIfError(err);

            }

        }

    if ( !aMessage.IsNull() )

        {

        aMessage.Complete( KErrNone );

        }

    }

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

// CUpnpMediaServerSession::EventMediaServerStartOfflineL

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

//

void CUpnpMediaServerSession::EventMediaServerStartOfflineL( const RMessage2& aMessage )

    {

    iMediaServer->CancelAVMediaServerStop();//if stop was scheduled cancel it

    if( iMediaServer->Status() != RUpnpMediaServerClient::EStartedOffline )

        {

        TRAPD(err, iMediaServer->StartAVMediaServerOfflineL());

         if ( err == KErrNotFound // files not found

            || err == KErrArgument // empty or improper one of description files

            || (err >= EXmlParserError && err <= EXmlFeatureLockedWhileParsing) // description malformed

            || err == KErrNoMemory // problem with start because of memory usage

            )

            {

            iMediaServer->InitializeL( ETrue );

            iMediaServer->StartAVMediaServerOfflineL();

            }

        else if (err == KErrCorrupt || err == KErrEof)

            {

            iMediaServer->ResetDbL();

            iMediaServer->StartAVMediaServerOfflineL();

            }

        else

            {

            User::LeaveIfError(err);

            }

        }

    aMessage.Complete( KErrNone );

    }

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

// CUpnpMediaServerSession::EventMediaServerStop

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

//

void CUpnpMediaServerSession::EventMediaServerStop( const RMessage2& aMessage )

    {

    if ( iMediaServer->Status() != RUpnpMediaServerClient::EStopped )

        {

        iMediaServer->StopAVMediaServer(EFalse);

        }

    aMessage.Complete( KErrNone );

    }

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

// CUpnpMediaServerSession::EventMediaServerStopSilent

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

//

void CUpnpMediaServerSession::EventMediaServerStopSilent( const RMessage2& aMessage )

    {

    if ( iMediaServer->Status() != RUpnpMediaServerClient::EStopped )

        {

        iMediaServer->StopAVMediaServer(ETrue);

        }

    aMessage.Complete( KErrNone );

    }

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

// CUpnpMediaServerSession::EventMediaServerRestartL

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

//

void CUpnpMediaServerSession::EventMediaServerRestartL( const RMessage2& aMessage )

    {

    iMediaServer->RestartAVMediaServerL();

    aMessage.Complete( KErrNone );

    }

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

// CUpnpMediaServerSession::EventMediaServerGetShareItemResultL

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

//

void CUpnpMediaServerSession::EventMediaServerGetShareItemResultL( const RMessage2& aMessage )

    {

    ASSERT(aMessage.GetDesMaxLength(0) >= iRespLength);

    // Write result back to client

    aMessage.WriteL( 0, *iResponseBuffer );

    aMessage.Complete( KErrNone );

    // clean up

    delete iResponseBuffer;

    iResponseBuffer = NULL;

    }

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

// CUpnpMediaServerSession::EventMediaServerGetShareContainerResultL

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

//

void CUpnpMediaServerSession::EventMediaServerGetShareContainerResultL( const RMessage2& aMessage )

    {

    ASSERT(aMessage.GetDesMaxLength(0) >= iRespLength);

    // Write result back to client

    aMessage.WriteL( 0, *iResponseBuffer );

    aMessage.Complete( KErrNone );

    // clean up

    delete iResponseBuffer;

    iResponseBuffer = NULL;

    }

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

// CUpnpMediaServerSession::EventMediaServerShareItemL

// Stops the server.

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

//

void CUpnpMediaServerSession::EventMediaServerShareItemL( const RMessage2& aMessage )

    {

    // get object from message

    CUpnpItem* item = CUpnpItem::NewL();

    CleanupStack::PushL(item);

    ReadObjFromMessageL(aMessage, 0, item);

    // perform action

    iMediaServer->ShareObjectL(item);

    // prepare response

    iResponseBuffer = item->ToDes8L();

    iRespLength = iResponseBuffer->Length();

    aMessage.WriteL(1, iRespLengthPkg);

    aMessage.Complete( KErrNone );

    // clean up

    CleanupStack::PopAndDestroy(item);

    }

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

// CUpnpMediaServerSession::EventMediaServerGetSharedItemL

// Stops the server.

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

//

void CUpnpMediaServerSession::EventMediaServerGetSharedItemL(

                                                    const RMessage2& aMessage )

    {

    // perform action

    CUpnpItem* item = iMediaServer->GetSharedItemL(aMessage.Int0());

    CleanupStack::PushL(item);

    // prepare response

    iResponseBuffer = item->ToDes8L();

    iRespLength = iResponseBuffer->Length();

    aMessage.WriteL(1, iRespLengthPkg);

    aMessage.Complete( KErrNone );

    // clean up

    CleanupStack::PopAndDestroy(item);

    }

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

// CUpnpMediaServerSession::EventMediaServerGetGetSharedItemResultL

// Stops the server.

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

//

void CUpnpMediaServerSession::EventMediaServerGetGetSharedItemResultL(

                                                    const RMessage2& aMessage )

    {

    ASSERT(aMessage.GetDesMaxLength(0) >= iRespLength);

    // Write result back to client

    aMessage.WriteL( 0, *iResponseBuffer );

    aMessage.Complete( KErrNone );

    // clean up

    delete iResponseBuffer;

    iResponseBuffer = NULL;

    }

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

// CUpnpMediaServerSession::EventMediaServerGetSharedContainerL

// Stops the server.

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

//

void CUpnpMediaServerSession::EventMediaServerGetSharedContainerL(

                                                    const RMessage2& aMessage )

    {

    // perform action

    CUpnpContainer* cont = iMediaServer->GetSingleContainerL(aMessage.Int0());

    CleanupStack::PushL(cont);

    // prepare response

    iResponseBuffer = cont->ToDes8L();

    iRespLength = iResponseBuffer->Length();

    aMessage.WriteL(1, iRespLengthPkg);

    aMessage.Complete( KErrNone );

    // clean up

    CleanupStack::PopAndDestroy(cont);

    }

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

// CUpnpMediaServerSession::EventMediaServerGetShareContainerListResultL

// Stops the server.

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

//

void CUpnpMediaServerSession::EventMediaServerGetGetSharedContainerResultL(

                                                    const RMessage2& aMessage )

    {

    ASSERT(aMessage.GetDesMaxLength(0) >= iRespLength);

    // Write result back to client

    aMessage.WriteL( 0, *iResponseBuffer );

    aMessage.Complete( KErrNone );

    // clean up

    delete iResponseBuffer;

    iResponseBuffer = NULL;

    }

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

// CUpnpMediaServerSession::EventMediaServerShareContainerL

// Stops the server.

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

//

void CUpnpMediaServerSession::EventMediaServerShareContainerL(

                                                    const RMessage2& aMessage )

    {

    // get object from message

    CUpnpContainer* cont = CUpnpContainer::NewL();

    CleanupStack::PushL(cont);

    ReadObjFromMessageL(aMessage, 0, cont);

    // perform action

    iMediaServer->ShareObjectL(cont);

    // prepare response

    iResponseBuffer = cont->ToDes8L();

    iRespLength = iResponseBuffer->Length();

    aMessage.WriteL(1, iRespLengthPkg);

    aMessage.Complete( KErrNone );

    // clean up