/*

* Copyright (c) 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:      AVController server side root class

*

*/

// INCLUDE FILES

// upnp stack api

#include <upnpdevice.h>

#include <upnpcontainer.h>

#include <upnpservice.h>

#include <upnpstatevariable.h>

#include <upnpaction.h>

#include <upnpobjectlist.h>

#include <upnpavcontrolpoint.h>

// upnpframework / avcontroller api

#include "upnpavdeviceobserver.h"

#include "upnpavdevicelist.h"

// avcontroller internal

#include "upnpavcontrollerimpl.h"

#include "upnpavcontrollerserver.h"

#include "upnpavdispatcher.h"

#include "upnpavdeviceextended.h"

#include "upnpdevicerepository.h"

#include "upnpaverrorhandler.h"

#include "upnpplaybacksession.h"

#include "upnpbrowsingsession.h"

#include "upnpdevicediscoverymessage.h"

#include "upnpuploadsession.h"

#include "upnpdownloadsession.h"

#include "upnpsecaccesscontroller.h"

_LIT( KComponentLogfile, "upnpavcontrollerserver.txt");

#include "upnplog.h"

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

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

// CUPnPAVControllerImpl::NewL

// See upnpavcontrollerimpl.h

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

CUPnPAVControllerImpl* CUPnPAVControllerImpl::NewL(

    RUpnpMediaServerClient& aClient,

    CUpnpAVControllerServer& aServer )

    {

    CUPnPAVControllerImpl* self = new (ELeave) CUPnPAVControllerImpl( 

        aClient, aServer );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CUPnPAVControllerImpl::CUPnPAVControllerImpl

// See upnpavcontrollerimpl.h

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

CUPnPAVControllerImpl::CUPnPAVControllerImpl(

    RUpnpMediaServerClient& aClient,

    CUpnpAVControllerServer& aServer ) :

    iMediaServer( aClient ),

    iServer( aServer ),

    iDeviceDiscoveryEnabled( EFalse),

    iDeviceMsgQue( CUpnpDeviceDiscoveryMessage::LinkOffset() ),

    iDeviceMsgQueIter( iDeviceMsgQue )

    {

    }

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

// CUPnPAVControllerImpl::~CUPnPAVControllerImpl

// See upnpavcontrollerimpl.h

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

CUPnPAVControllerImpl::~CUPnPAVControllerImpl()

    {

    __LOG( "CUPnPAVControllerImpl::~CUPnPAVControllerImpl" );

    delete iDeviceRespBuf;

    delete iDeviceListRespBuf;

    iPlaybackSessions.ResetAndDestroy();

    iBrowsingSessions.ResetAndDestroy();

    iUploadSessions.ResetAndDestroy();

    iDownloadSessions.ResetAndDestroy();

    CUpnpDeviceDiscoveryMessage* devMsg = NULL;

    iDeviceMsgQueIter.SetToFirst(); 

    while ( ( devMsg = iDeviceMsgQueIter++ ) != NULL )

        {

        iDeviceMsgQue.Remove( *devMsg );

        delete devMsg;

        };    

    delete iConnectionMsg; iConnectionMsg = NULL;

    delete iDeviceDiscoveryMsg; iDeviceDiscoveryMsg = NULL;        

    }

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

// CUPnPAVControllerImpl::ConstructL

// See upnpavcontrollerimpl.h

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

void CUPnPAVControllerImpl::ConstructL()

    {

    __LOG( "CUPnPAVControllerImpl::ConstructL" );    

    }

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

// CUPnPAVControllerImpl::ConnectionLost

// See upnpavcontrollerimpl.h

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

void CUPnPAVControllerImpl::ConnectionLost()

    {

    if( iConnectionMsg )

        {

        iConnectionMsg->Complete( EAVControllerConnectionLost );

        delete iConnectionMsg; iConnectionMsg = NULL;

        }

    else

        {

        // No msg, no can do

        }    

    }

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

// CUPnPAVControllerImpl::DeviceDiscoveredL

// See upnpavcontrollerimpl.h

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

void CUPnPAVControllerImpl::DeviceDiscoveredL(

    CUpnpAVDeviceExtended& aDevice )

    {

    __LOG( "CUPnPAVControllerImpl::DeviceDiscoveredL" );

    if( aDevice.DeviceType() == CUpnpAVDevice::EMediaServer &&

        ( aDevice.Local() ) )

        {

        TInt i;

        TInt count = iPlaybackSessions.Count();

        for( i = 0; i < count; i++ )

            {

            iPlaybackSessions[ i ]->SetLocalMSUuidL( aDevice.Uuid() );

            }

        count = iBrowsingSessions.Count();

        for( i = 0; i < count; i++ )

            {

            iBrowsingSessions[ i ]->SetLocalMSUuidL( aDevice.Uuid() );

            }

        }

    else if( iDeviceDiscoveryEnabled )

        {

        CUpnpAVDevice* tempDev = CUpnpAVDevice::NewL( aDevice ); 

        if( iDeviceDiscoveryMsg )

            {

            CleanupStack::PushL( tempDev );

            delete iDeviceRespBuf; iDeviceRespBuf = NULL;

            iDeviceRespBuf = tempDev->ToDes8L();

            CleanupStack::PopAndDestroy( tempDev );

            // Write back to the client that a device was discovered

            // of the device and the size

            TPckg<TAVControllerDeviceDiscovery> resp0( EAVDeviceDiscovered );

            TPckg<TInt> resp1( iDeviceRespBuf->Length() );

            iDeviceDiscoveryMsg->WriteL( 0, resp0 );

            iDeviceDiscoveryMsg->WriteL( 1, resp1 );

            iDeviceDiscoveryMsg->Complete( EAVControllerDeviceCompleted );

            delete iDeviceDiscoveryMsg; iDeviceDiscoveryMsg = NULL;

            }

        else

            {

            // Msg not valid, client is still processing.. 

            //add the discovered device to queue

            CUpnpDeviceDiscoveryMessage* tmpDevMsg = 

                    CUpnpDeviceDiscoveryMessage::NewL( 

                    tempDev, EAVDeviceDiscovered );

            iDeviceMsgQue.AddLast( *tmpDevMsg );

            }

        }

    }

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

// CUPnPAVControllerImpl::DeviceDisappearedL

// See upnpavcontrollerimpl.h

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

void CUPnPAVControllerImpl::DeviceDisappearedL(

    CUpnpAVDeviceExtended& aDevice )

    {

    __LOG( "CUPnPAVControllerImpl::DeviceDisappearedL" );

    // Go through browsing and rendering sessions and report if their

    // device or the local MS disappeared

    TBool localMs = EFalse;

    if( aDevice.DeviceType() == CUpnpAVDevice::EMediaServer &&

        ( aDevice.Local() ) )

        {

        __LOG( "CUPnPAVControllerImpl::DeviceDisappearedL\

        - Local MS disappeared!" );

         // Local MS disappeared

         localMs = ETrue;

        }

    TInt i;

    TInt count = iPlaybackSessions.Count();

    for( i = 0; i < count; i++ )

        {

        if( ( iPlaybackSessions[ i ]->Uuid() == aDevice.Uuid() ) ||

            ( localMs ) )

            {

            iPlaybackSessions[ i ]->DeviceDisappearedL( aDevice );

            }     

        }

    count = iBrowsingSessions.Count();

    for( i = 0; i < count; i++ )

        {

        if( ( iBrowsingSessions[ i ]->Uuid() == aDevice.Uuid() ) ||

            ( localMs ) )

            {

            iBrowsingSessions[ i ]->DeviceDisappearedL( aDevice );

            }     

        }

    count = iUploadSessions.Count();

    for( i = 0; i < count; i++ )

        {

        if( iUploadSessions[ i ]->Uuid() == aDevice.Uuid() )

            {

            iUploadSessions[ i ]->DeviceDisappearedL( aDevice );

            }     

        }

    count = iDownloadSessions.Count();

    for( i = 0; i < count; i++ )

        {

        if( iDownloadSessions[ i ]->Uuid() == aDevice.Uuid() )

            {

            iDownloadSessions[ i ]->DeviceDisappearedL( aDevice );

            }     

        }

    if( iDeviceDiscoveryEnabled )

        {       

        // Create a device (buffer)

        CUpnpAVDevice* tempDev = CUpnpAVDevice::NewL( aDevice );

         if( iDeviceDiscoveryMsg )

            {

            CleanupStack::PushL( tempDev );

            delete iDeviceRespBuf; iDeviceRespBuf = NULL;

            iDeviceRespBuf = tempDev->ToDes8L();

            CleanupStack::PopAndDestroy( tempDev );

            // Write back to the client that a device was discovered

            // and the size of the device

            TPckg<TAVControllerDeviceDiscovery> resp0(

                EAVDeviceDisappeared );

            TPckg<TInt> resp1( iDeviceRespBuf->Length() );

            iDeviceDiscoveryMsg->WriteL( 0, resp0 );

            iDeviceDiscoveryMsg->WriteL( 1, resp1 );

            iDeviceDiscoveryMsg->Complete( EAVControllerDeviceCompleted );

            delete iDeviceDiscoveryMsg; iDeviceDiscoveryMsg = NULL;

            }

        else

            {

            // Msg not valid, client is still processing.. 

            //add the disappeared device to queue

            CUpnpDeviceDiscoveryMessage* tmpDevMsg = 

                    CUpnpDeviceDiscoveryMessage::NewL( 

                    tempDev, EAVDeviceDisappeared );

            iDeviceMsgQue.AddLast( *tmpDevMsg );

            }

        }

    }    

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

// CUPnPAVControllerImpl::EnableDeviceDiscoveryL

// See upnpavcontrollerimpl.h

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

void CUPnPAVControllerImpl::EnableDeviceDiscoveryL(

    const RMessage2& aMessage )

    {

    __LOG( "CUPnPAVControllerImpl::EnableDeviceDiscoveryL" );

    __ASSERTD( !iDeviceDiscoveryMsg, __FILE__, __LINE__ );

    if( !iDeviceDiscoveryEnabled )

        {

        //iDispatcher.RegisterForDeviceDiscoveryL( *this );

        iDeviceDiscoveryEnabled = ETrue;    

        }

    iDeviceDiscoveryMsg = new (ELeave) RMessage2( aMessage );

    // Check queu's

    if( !iDeviceMsgQue.IsEmpty() )

        {

        CUpnpDeviceDiscoveryMessage* devMsg = iDeviceMsgQue.First();

        __ASSERTD( devMsg, __FILE__, __LINE__ );

        CUpnpAVDevice* dev = devMsg->Device();

        TAVControllerDeviceDiscovery devMsgType = devMsg->MsgType();

        DequeDeviceL( *dev, devMsgType );

        iDeviceMsgQue.Remove( *devMsg );

        delete devMsg;

        }

    else

        {

        // Empty else

        }             

    }

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

// CUPnPAVControllerImpl::DequeDeviceL

// See upnpavcontrollerimpl.h

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

void CUPnPAVControllerImpl::DequeDeviceL( const CUpnpAVDevice& aDevice,

    TAVControllerDeviceDiscovery aType )

    {

    __LOG( "CUPnPAVControllerImpl::DequeDeviceL" );

    TPckg<TAVControllerDeviceDiscovery> resp0( aType );

    iDeviceDiscoveryMsg->WriteL( 0, resp0 );

    HBufC8* tmp = aDevice.ToDes8L();

    CleanupStack::PushL( tmp );

    TPckg<TInt> resp1( tmp->Length() );            

    iDeviceDiscoveryMsg->WriteL( 1, resp1 );

    CleanupStack::Pop( tmp );

    delete iDeviceRespBuf; iDeviceRespBuf = NULL;

    iDeviceRespBuf = tmp;

    iDeviceDiscoveryMsg->Complete( EAVControllerDeviceCompleted );

    delete iDeviceDiscoveryMsg; iDeviceDiscoveryMsg = NULL;

    }

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

// CUPnPAVControllerImpl::GetDeviceL

// See upnpavcontrollerimpl.h

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

void CUPnPAVControllerImpl::GetDeviceL( const RMessage2& aMessage )

    {

    __LOG1( "CUPnPAVControllerImpl::GetDeviceL, 0x%d", iDeviceRespBuf );

    aMessage.WriteL( 0, *iDeviceRespBuf );

    aMessage.Complete( KErrNone );

    delete iDeviceRespBuf; iDeviceRespBuf = NULL;

    }

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

// CUPnPAVControllerImpl::DisableDeviceDiscoveryL

// See upnpavcontrollerimpl.h

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

void CUPnPAVControllerImpl::DisableDeviceDiscoveryL(

    /*const RMessage2& aMessage*/ )

    {

    __LOG( "CUPnPAVControllerImpl::DisableDeviceDiscoveryL" );

    if( iDeviceDiscoveryEnabled )

        {

        //iDispatcher.UnRegisterDeviceDiscovery( *this );

        iDeviceDiscoveryEnabled = EFalse;    

        }

    if( iDeviceDiscoveryMsg )

        { 

        iDeviceDiscoveryMsg->Complete( KErrCancel );

        delete iDeviceDiscoveryMsg; iDeviceDiscoveryMsg = NULL;        

        }

    }

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

// CUPnPAVControllerImpl::GetDeviceListSizeL

// See upnpavcontrollerimpl.h

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

void CUPnPAVControllerImpl::GetDeviceListSizeL( const RMessage2& aMessage )

    {

    __LOG( "CUPnPAVControllerImpl::GetDeviceListSizeL" );

    // Get the device list from the av control point, create a response buffer

    // and write the size of the list back to the client

    TAVControllerDeviceListType deviceListType;

    TPckg<TAVControllerDeviceListType> resp0( deviceListType );

    aMessage.ReadL( 0, resp0 );

    delete iDeviceListRespBuf; iDeviceListRespBuf = NULL;

    const RPointerArray<CUpnpAVDeviceExtended>& devList =

        iServer.DeviceRepository().DeviceList();

    if( deviceListType == EAVMediaServer )

        {

        CUpnpAVDeviceList* tempList = CUpnpAVDeviceList::NewLC();

        TInt count = devList.Count();

        for( TInt i = 0; i < count; i++ )

            {

            if( devList[ i ]->DeviceType() == CUpnpAVDevice::EMediaServer )

                {

                if( devList[ i ]->PInfoReceived() &&

                    !devList[ i ]->Local() )

                    {

                    CUpnpAVDevice* tempDev = CUpnpAVDevice::NewL(

                        *devList[i] );

                    // Ownership of tempDev transferred

                    tempList->AppendDeviceL( *tempDev );

                    }

                }

            }

        iDeviceListRespBuf = tempList->ToDes8L();

        CleanupStack::PopAndDestroy( tempList );

        }

    else

        {

        CUpnpAVDeviceList* tempList = CUpnpAVDeviceList::NewLC();

        TInt count = devList.Count();

        for( TInt i = 0; i < count; i++ )

            {

            if( devList[ i ]->DeviceType() == CUpnpAVDevice::EMediaRenderer )

                {

                if( devList[ i ]->PInfoReceived() )

                    {

                    CUpnpAVDevice* tempDev = CUpnpAVDevice::NewL(

                        *devList[i] );

                    // Ownership of tempDev transferred

                    tempList->AppendDeviceL( *tempDev );                    

                    }

                }

            }

        iDeviceListRespBuf = tempList->ToDes8L();

        CleanupStack::PopAndDestroy( tempList ); 

        }    

    // Write the size back to the client

    TPckg<TInt> resp1( iDeviceListRespBuf->Length() );

    aMessage.WriteL( 1, resp1 );

    aMessage.Complete( KErrNone );

    }

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

// CUPnPAVControllerImpl::GetDeviceListL

// See upnpavcontrollerimpl.h

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

void CUPnPAVControllerImpl::GetDeviceListL( const RMessage2& aMessage )

    {

    __LOG1( "CUPnPAVControllerImpl::GetDeviceListL, 0x%d",

        iDeviceListRespBuf );

    // Write the device list back to the client

    aMessage.WriteL( 0, *iDeviceListRespBuf );

    aMessage.Complete( KErrNone );

    delete iDeviceListRespBuf; iDeviceListRespBuf = NULL;    

    }

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

// CUPnPAVControllerImpl::CreateRenderingSessionL

// See upnpavcontrollerimpl.h

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

void CUPnPAVControllerImpl::CreateRenderingSessionL(

    const RMessage2& aMessage )

    {

    __LOG1( "CUPnPAVControllerImpl::CreateRenderingSessionL, 0x%d",

        aMessage.Int0() );

    // Create a rendering session

    TInt id = aMessage.Int0();

    // Read the device UID

    TInt len = aMessage.GetDesMaxLength( 1 );

    HBufC8* buf = HBufC8::NewLC( len );

    TPtr8 ptr( buf->Des() );

    User::LeaveIfError( aMessage.Read( 1, ptr ) );

    CUPnPPlaybackSession* tempPtr = CUPnPPlaybackSession::NewL(

        iMediaServer, iServer, id, *buf );

    CleanupStack::PopAndDestroy( buf );

    iPlaybackSessions.Append( tempPtr );

    aMessage.Complete( KErrNone );

    }

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

// CUPnPAVControllerImpl::DestroyRenderingSessionL

// See upnpavcontrollerimpl.h

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

void CUPnPAVControllerImpl::DestroyRenderingSessionL(

    const RMessage2& aMessage )

    {