/** @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
    CleanupStack::PopAndDestroy(cont);
    }

// -----------------------------------------------------------------------------
// CUpnpMediaServerSession::EventMediaServerGetShareItemListResultL
// -----------------------------------------------------------------------------
//
void CUpnpMediaServerSession::EventMediaServerGetGetSharedItemListResultL(
                                                    const RMessage2& aMessage )
    {
    ASSERT(aMessage.GetDesMaxLength(0) >= iRespLength);

    // Write result back to client
    aMessage.WriteL( 0, *iResponseBuffer );
    aMessage.WriteL( 1, iRespExecStatusPkg );
    aMessage.Complete( KErrNone );

    // clean up
    delete iResponseBuffer;
    iResponseBuffer = NULL;
    }

// -----------------------------------------------------------------------------
// CUpnpMediaServerSession::EventMediaServerGetGetSharedContainerListResultL
// -----------------------------------------------------------------------------
//
void CUpnpMediaServerSession::EventMediaServerGetGetSharedContainerListResultL(
                                                    const RMessage2& aMessage )
    {
    ASSERT(aMessage.GetDesMaxLength(0) >= iRespLength);

    // Write result back to client
    aMessage.WriteL( 0, *iResponseBuffer );
    aMessage.WriteL( 1, iRespExecStatusPkg );
    aMessage.Complete( KErrNone );

    // clean up
    delete iResponseBuffer;
    iResponseBuffer = NULL;
    }

// -----------------------------------------------------------------------------
// CUpnpMediaServerSession::EventMediaServerGetShareItemListResultL
// -----------------------------------------------------------------------------
//
void CUpnpMediaServerSession::EventMediaServerGetShareItemListResultL( const RMessage2& aMessage )
    {
    ASSERT(aMessage.GetDesMaxLength(0) >= iRespLength);

    // Write result back to client
    aMessage.WriteL( 0, *iResponseBuffer );
    aMessage.WriteL( 1, iRespExecStatusPkg );
    aMessage.Complete( KErrNone );

    // clean up
    delete iResponseBuffer;
    iResponseBuffer = NULL;
    }
// -----------------------------------------------------------------------------
// CUpnpMediaServerSession::EventMediaServerUnshareRootL
// -----------------------------------------------------------------------------
//
void CUpnpMediaServerSession::EventMediaServerUnshareRootL(
                                                    const RMessage2& aMessage )
    {
    iMediaServer->UnshareRootL();
    aMessage.Complete( KErrNone );
    }
// -----------------------------------------------------------------------------
// CUpnpMediaServerSession::EventMediaServerUnshareItemL
// -----------------------------------------------------------------------------
//
void CUpnpMediaServerSession::EventMediaServerUnshareItemL(
                                                    const RMessage2& aMessage )
    {
    iMediaServer->UnshareItemL(aMessage.Int0());
    aMessage.Complete( KErrNone );
    }

// -----------------------------------------------------------------------------
// CUpnpMediaServerSession::EventMediaServerUnshareContainerL
// -----------------------------------------------------------------------------
//
void CUpnpMediaServerSession::EventMediaServerUnshareContainerL(
                                                    const RMessage2& aMessage )
    {
    iMediaServer->UnshareContainerL(aMessage.Int0());
    aMessage.Complete( KErrNone );
    }

// -----------------------------------------------------------------------------
// CUpnpMediaServerSession::EventMediaServerGetSharedItemListL
// -----------------------------------------------------------------------------
//
void CUpnpMediaServerSession::EventMediaServerGetSharedItemListL(
                                                    const RMessage2& aMessage )
    {
    // get object from message
    CUpnpBrowseCriteria* bc = CUpnpBrowseCriteria::NewL();
    CleanupStack::PushL(bc);
    ReadObjFromMessageL(aMessage, 1, bc);

    // item list
    CUpnpItemList* il = CUpnpItemList::NewL();
    CleanupStack::PushL(il);

    // perform action
    iMediaServer->GetSharedItemListL(aMessage.Int0(), bc, &iRespExecStatus, il);

    // prepare response
    iResponseBuffer = il->ToDes8L();
    iRespLength = iResponseBuffer->Length();
    aMessage.WriteL(2, iRespLengthPkg);
    aMessage.Complete( KErrNone );

    // clean up
    CleanupStack::PopAndDestroy(il);
    CleanupStack::PopAndDestroy(bc);
    }

// -----------------------------------------------------------------------------
// CUpnpMediaServerSession::EventMediaServerGetSharedContainerListL
// -----------------------------------------------------------------------------
//
void CUpnpMediaServerSession::EventMediaServerGetSharedContainerListL(
                                                    const RMessage2& aMessage )
    {
    // get object from message
    CUpnpBrowseCriteria* bc = CUpnpBrowseCriteria::NewL();
    CleanupStack::PushL(bc);
    ReadObjFromMessageL(aMessage, 1, bc);

    // item list
    CUpnpContainerList* cl = CUpnpContainerList::NewL();
    CleanupStack::PushL(cl);

    // perform action
    iMediaServer->GetSharedContainerListL(aMessage.Int0(),
                                            bc, &iRespExecStatus, cl);

    // prepare response
    iResponseBuffer = cl->ToDes8L();
    iRespLength = iResponseBuffer->Length();
    aMessage.WriteL(2, iRespLengthPkg);
    aMessage.Complete( KErrNone );

    // clean up
    CleanupStack::PopAndDestroy(cl);
    CleanupStack::PopAndDestroy(bc);
    }

// -----------------------------------------------------------------------------
// CUpnpMediaServerSession::EventMediaServerShareItemListL
// -----------------------------------------------------------------------------
//
void CUpnpMediaServerSession::EventMediaServerShareItemListL(
                                                    const RMessage2& aMessage )
    {
    // get object from message
    CUpnpItemList* il = CUpnpItemList::NewL();
    CleanupStack::PushL(il);
    ReadObjFromMessageL(aMessage, 0, il);

    // perform action
    iMediaServer->ShareItemListL(il, &iRespExecStatus);

    // prepare response
    iResponseBuffer = il->ToDes8L();
    iRespLength = iResponseBuffer->Length();
    aMessage.WriteL(1, iRespLengthPkg);
    aMessage.Complete( KErrNone );

    // clean up
    CleanupStack::PopAndDestroy(il);
    }

// -----------------------------------------------------------------------------
// CUpnpMediaServerSession::EventMediaServerUnshareItemListL
// -----------------------------------------------------------------------------
//
void CUpnpMediaServerSession::EventMediaServerUnshareItemListL(
                                                    const RMessage2& aMessage )
    {
    // get ids from message
    RArray<TInt> il;
    CleanupClosePushL(il);
    ReadIdsFromMessageL(aMessage, 0, il);

    // perform action
    iMediaServer->UnshareItemListL(il, &iRespExecStatus);

    // prepare response
    aMessage.WriteL( 1, iRespExecStatusPkg );
    aMessage.Complete( KErrNone );

    // clean up
    CleanupStack::PopAndDestroy(&il);
    }

// -----------------------------------------------------------------------------
// CUpnpMediaServerSession::EventMediaServerGetIpAndPortL
// -----------------------------------------------------------------------------
//
void CUpnpMediaServerSession::EventMediaServerGetIpAndPortL(
                                                    const RMessage2& aMessage )
    {
    // response
    TInetAddr address = iMediaServer->GetAddress();
    if (address.Match(TInetAddr(INET_ADDR(0, 0, 0, 0))))
        {
        User::Leave( KErrNotReady );
        }
    aMessage.WriteL( 0, TPckgBuf<TInetAddr>( address ) );
    aMessage.Complete( KErrNone );
    }

// -----------------------------------------------------------------------------
// CUpnpMediaServerSession::EventSetUploadDirectoryL
// -----------------------------------------------------------------------------
//
void CUpnpMediaServerSession::EventSetUploadDirectoryL( const RMessage2& aMessage )
    {
    HBufC* buf = HBufC::NewLC( aMessage.GetDesLength( 0 ) );
    TPtr ptr( buf->Des() );
    User::LeaveIfError( aMessage.Read( 0, ptr ) );
    iMediaServer->SetUploadDirToCDL( ptr );
    CleanupStack::PopAndDestroy(buf);
    aMessage.Complete( KErrNone );
    }
// -----------------------------------------------------------------------------
// CUpnpMediaServerSession::EventAddIcon
// -----------------------------------------------------------------------------
//
void CUpnpMediaServerSession::EventAddIconL( const RMessage2& aMessage)
    {
    HBufC8* buf = HBufC8::NewLC( aMessage.GetDesLength( 0 ) );
    TPtr8 ptr( buf->Des() );
    User::LeaveIfError( aMessage.Read( 0, ptr ) );

    iMediaServer->AddIconL(ptr);
    CleanupStack::PopAndDestroy(buf);
    aMessage.Complete( KErrNone );
    }

// -----------------------------------------------------------------------------
// CUpnpMediaServerSession::EventUpdateIcon
// -----------------------------------------------------------------------------
//
void CUpnpMediaServerSession::EventUpdateIconL( const RMessage2& aMessage)
    {
    HBufC8* buf0 = HBufC8::NewLC( aMessage.GetDesLength( 0 ) );
    TPtr8 ptr0( buf0->Des() );
    User::LeaveIfError( aMessage.Read( 0, ptr0 ) );

    HBufC8* buf1 = HBufC8::NewLC( aMessage.GetDesLength( 1 ) );
    TPtr8 ptr1( buf1->Des() );
    User::LeaveIfError( aMessage.Read( 1, ptr1 ) );

    iMediaServer->UpdateIconL(ptr0, ptr1);

    CleanupStack::PopAndDestroy(buf1);
    CleanupStack::PopAndDestroy(buf0);

    aMessage.Complete( KErrNone );
    }

// -----------------------------------------------------------------------------
// CUpnpMediaServerSession::EventRemoveIcon
// -----------------------------------------------------------------------------
//
void CUpnpMediaServerSession::EventRemoveIconL( const RMessage2& aMessage)
    {
    //Remove icon
    HBufC8* buf = HBufC8::NewLC( aMessage.GetDesLength( 0 ) );
    TPtr8 ptr( buf->Des() );
    User::LeaveIfError( aMessage.Read( 0, ptr ) );

    iMediaServer->RemoveIconL(ptr);
    CleanupStack::PopAndDestroy(buf);

    aMessage.Complete( KErrNone );
    }
// -----------------------------------------------------------------------------
// CUpnpMediaServerSession::EventRemoveIcons
// -----------------------------------------------------------------------------
//
void CUpnpMediaServerSession::EventRemoveIconsL( const RMessage2& aMessage )
    {
    iMediaServer->RemoveIconsL();
    aMessage.Complete( KErrNone );
    }

// -----------------------------------------------------------------------------
// CUpnpMediaServerSession::ObjFromMessageL
// -----------------------------------------------------------------------------
//
void CUpnpMediaServerSession::ReadIdsFromMessageL( const RMessage2& aMessage,
                                        TInt aSlot, RArray<TInt>& aObjIds )
    {
    // create buffer
    TInt len = aMessage.GetDesMaxLength(aSlot);
    HBufC8* buf = HBufC8::NewLC(len);
    TPtr8 ptr(buf->Des());
    User::LeaveIfError(aMessage.Read(aSlot, ptr));

    // read stream
    RDesReadStream stream(*buf);
    CleanupClosePushL(stream);

    // number of elements
    TInt n = stream.ReadInt32L();

    // variables used to retrieve integers
    HBufC8* tmpId;
    TLex8 lex;
    TInt tmpIdNum;
    // read elements
    while( n-- )
        {
        tmpId = HBufC8::NewLC(stream, KMaxUpnpObjStringLen);
        if ( tmpId->Des() == KNullDesC8() )
            {
            User::Leave( KErrNotFound );
            }
        lex.Assign(tmpId->Des());
        if( lex.Val( tmpIdNum ) < KErrNone )
            {
            User::Leave( KErrNotFound );
            }
        aObjIds.AppendL( tmpIdNum);
        CleanupStack::PopAndDestroy(tmpId);
        }

    // clean up
    CleanupStack::PopAndDestroy(&stream);
    CleanupStack::PopAndDestroy(buf);
    }
// -----------------------------------------------------------------------------
// CUpnpMediaServerSession::ObjFromMessageL
// -----------------------------------------------------------------------------
//
void CUpnpMediaServerSession::ReadObjFromMessageL( const RMessage2& aMessage,
                                                TInt aSlot, CUpnpObject* aObj )
    {
    // create buffer
    TInt len = aMessage.GetDesMaxLength(aSlot);
    HBufC8* buf = HBufC8::NewLC(len);
    TPtr8 ptr(buf->Des());
    User::LeaveIfError(aMessage.Read(aSlot, ptr));

    // read stream
    RDesReadStream stream(*buf);
    CleanupClosePushL(stream);

    // internalize object
    stream >> *aObj;

    // clean up
    CleanupStack::PopAndDestroy(&stream);
    CleanupStack::PopAndDestroy(buf);
    }

// -----------------------------------------------------------------------------
// CUpnpMediaServerSession::ReadItemFromMessageL
// -----------------------------------------------------------------------------
//
void CUpnpMediaServerSession::ReadItemFromMessageL( const RMessage2& aMessage,
                                                TInt aSlot, CUpnpItem* aItem )
    {
    // create buffer
    TInt len = aMessage.GetDesMaxLength(aSlot);
    HBufC8* buf = HBufC8::NewLC(len);
    TPtr8 ptr(buf->Des());
    User::LeaveIfError(aMessage.Read(aSlot, ptr));

    // read stream
    RDesReadStream stream(*buf);
    CleanupClosePushL(stream);

    // internalize object
    stream >> *aItem;

    // clean up
    CleanupStack::PopAndDestroy(&stream);
    CleanupStack::PopAndDestroy(buf);
    }

// -----------------------------------------------------------------------------
// CUpnpMediaServerSession::ReadObjFromMessageL
// -----------------------------------------------------------------------------
//
void CUpnpMediaServerSession::ReadObjFromMessageL( const RMessage2& aMessage,
                                        TInt aSlot, CUpnpItemList* aItemList )
    {
    // create buffer
    TInt len = aMessage.GetDesMaxLength(aSlot);
    HBufC8* buf = HBufC8::NewLC(len);
    TPtr8 ptr(buf->Des());
    User::LeaveIfError(aMessage.Read(aSlot, ptr));

    // read stream
    RDesReadStream stream(*buf);
    CleanupClosePushL(stream);

    // internalize object
    stream >> *aItemList;

    // clean up
    CleanupStack::PopAndDestroy(&stream);
    CleanupStack::PopAndDestroy(buf);
    }

// -----------------------------------------------------------------------------
// CUpnpMediaServerSession::ReadObjFromMessageL
// -----------------------------------------------------------------------------
//
void CUpnpMediaServerSession::ReadObjFromMessageL( const RMessage2& aMessage,
                            TInt aSlot, CUpnpBrowseCriteria* aBrowseCriteria )
    {
    // create buffer
    TInt len = aMessage.GetDesMaxLength(aSlot);
    HBufC8* buf = HBufC8::NewLC(len);
    TPtr8 ptr(buf->Des());
    User::LeaveIfError(aMessage.Read(aSlot, ptr));

    // read stream
    RDesReadStream stream(*buf);
    CleanupClosePushL(stream);

    // internalize object
    stream >> *aBrowseCriteria;

    // clean up
    CleanupStack::PopAndDestroy(&stream);
    CleanupStack::PopAndDestroy(buf);
    }

// -----------------------------------------------------------------------------
// CUpnpMediaServerSession::EventMediaServerShareReferenceL
// -----------------------------------------------------------------------------
//
void CUpnpMediaServerSession::EventMediaServerShareReferenceL( const RMessage2& aMessage )
    {
    // get 'reference object' from message
    CUpnpItem* ref = CUpnpItem::NewL();
    CleanupStack::PushL(ref);
    ReadItemFromMessageL(aMessage, 0, ref);

    // perform sharing
    iMediaServer->ShareReferenceL(ref);

    // prepare response
    iResponseBuffer = ref->ToDes8L();
    iRespLength = iResponseBuffer->Length();
    aMessage.WriteL(1, iRespLengthPkg);
    aMessage.Complete( KErrNone );

    // clean up
    CleanupStack::PopAndDestroy(ref);
    }

// -----------------------------------------------------------------------------
// CUpnpMediaServerSession::EventMediaServerShareReferenceListL
// -----------------------------------------------------------------------------
//
void CUpnpMediaServerSession::EventMediaServerShareReferenceListL( const RMessage2& aMessage )
    {
    // get 'reference item' list from message
    CUpnpItemList* refList = CUpnpItemList::NewL();
    CleanupStack::PushL(refList);
    ReadObjFromMessageL(aMessage, 0, refList);

    // perform sharing
    iMediaServer->ShareReferenceListL(refList, &iRespExecStatus);

    // prepare response
    iResponseBuffer = refList->ToDes8L();
    iRespLength = iResponseBuffer->Length();
    aMessage.WriteL(1, iRespLengthPkg);
    aMessage.Complete( KErrNone );

    // clean up
    CleanupStack::PopAndDestroy(refList);
    }

// -----------------------------------------------------------------------------
// CUpnpMediaServerSession::EventMediaServerStatusChangeL
// -----------------------------------------------------------------------------
//
void CUpnpMediaServerSession::EventMediaServerStatusChange( const RMessage2& aMessage )
    {
    if ( !iStatusMessage.IsNull() )
        {
        aMessage.Complete( KErrInUse );
        }
    else
        {
        iStatusMessage = aMessage;
        }    
    }
    
// -----------------------------------------------------------------------------
// CUpnpMediaServerSession::EventMediaServerStatusChangeCancelL
// -----------------------------------------------------------------------------
//
void CUpnpMediaServerSession::EventMediaServerStatusChangeCancel( const RMessage2& aMessage )
    {
    if ( !iStatusMessage.IsNull() )
        {
        iStatusMessage.Complete( KErrCancel );
        }
    aMessage.Complete( KErrNone );
    }
    
// -----------------------------------------------------------------------------
// CUpnpMediaServerSession::StatusChanged
// -----------------------------------------------------------------------------
//
void CUpnpMediaServerSession::StatusChanged()
    {
    if ( !iStatusMessage.IsNull() )
        {
        iStatusMessage.Complete( KErrNone );
        }
    }

// End of File