/*

* 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:      storage for devices with extended information

*

*/

// INCLUDE FILES

#include "upnpdevicerepository.h"

#include "upnpavdeviceextended.h"

#include <upnpservice.h>

#include <upnpdevice.h>

#include <upnpavcontrolpoint.h>

// CONSTANTS

_LIT8( KSearch,                     "Search" );

_LIT8( KVolume,                     "Volume" );

_LIT8( KCreateObject,               "CreateObject" );

_LIT8( KPause,                      "Pause");

_LIT8( KSetVolume,                  "SetVolume");

_LIT8( KGetVolume,                  "GetVolume");

_LIT8( KGetMute,                    "GetMute");

_LIT8( KSetMute,                    "SetMute");

_LIT8( KMediaServer,                "MediaServer" );

_LIT8( KFriendlyName,               "friendlyName" );

_LIT8( KAVTransportService,         "AVTransport" );

_LIT8( KRenderingControlService,    "RenderingControl" );

_LIT8( KSetNextUri,                 "SetNextAVTransportURI" );

_LIT8( KDestroyObject,              "DestroyObject" );

_LIT8( KDlnaDoc,                    "dlna:X_DLNADOC" );

_LIT8( KDlnaCap,                    "dlna:X_DLNACAP" );

_LIT8( KAudioUpload,                "audio-upload" );

_LIT8( KImageUpload,                "image-upload" );

_LIT8( KVideoUpload,                "av-upload" );

_LIT8( KCreateChildContainer,       "create-child-container" );

_LIT8( KDMS,                        "DMS" );

_LIT8( KDMP,                        "DMP" );

_LIT8( KDMR,                        "DMR" );

const TInt KFirstSubscription = 1;

_LIT( KComponentLogfile, "upnpavcontrollerserver.txt");

#include "upnplog.h"

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

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

// CUPnPDeviceRepository::NewL

// See upnpdevicerepository.h

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

CUPnPDeviceRepository* CUPnPDeviceRepository::NewL

    (

    CUpnpAVControlPoint& aControlPoint

    )

    {

    CUPnPDeviceRepository* rep= new(ELeave)

        CUPnPDeviceRepository( aControlPoint );

    CleanupStack::PushL( rep );

    rep->ConstructL();

    CleanupStack::Pop();

    return rep;

    }

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

// CUPnPDeviceRepository::~CUPnPDeviceRepository

// See upnpdevicerepository.h

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

CUPnPDeviceRepository::~CUPnPDeviceRepository()

    {     

    iDevices.ResetAndDestroy();

    iDevices.Close();

    }

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

// CUPnPDeviceRepository::CUPnPDeviceRepository

// See upnpdevicerepository.h

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

CUPnPDeviceRepository::CUPnPDeviceRepository

    (

    CUpnpAVControlPoint& aControlPoint

    ):

    iControlPoint( aControlPoint ),

    iIsWlanActive( ETrue )    

    {

    }

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

// CUPnPDeviceRepository::ConstructL

// See upnpdevicerepository.h

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

void CUPnPDeviceRepository::ConstructL()

    {

    __LOG( "CUPnPDeviceRepository::ConstructL" );

    }

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

// CUPnPDeviceRepository::AddDeviceL

// See upnpdevicerepository.h

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

void CUPnPDeviceRepository::AddDeviceL( CUpnpDevice& aDevice )

    {

    __LOG( "CUPnPDeviceRepository::AddDeviceL" );

    CUpnpAVDeviceExtended* dev = CUpnpAVDeviceExtended::NewL();

    CleanupStack::PushL( dev );

    // Check if it's a dlna device

    TPtrC8 ptr = aDevice.GetProperty( KDlnaDoc );

    if( ptr.Length() > 0 )

        {

        __LOG( "Dlna compatible device!" );

        // It's a dlna device

        dev->SetDlnaCompatible( ETrue );

        if( ptr.FindC( KDMS ) != KErrNotFound )

            {

            dev->SetDLNADeviceType( CUpnpAVDeviceExtended::EDMS );

            }

        else if( ptr.FindC( KDMR ) != KErrNotFound )

            {

            dev->SetDLNADeviceType( CUpnpAVDeviceExtended::EDMR );

            }

        else if( ptr.FindC( KDMP ) != KErrNotFound )

            {

            dev->SetDLNADeviceType( CUpnpAVDeviceExtended::EDMP );

            }        

        // Check dlna capabilities

        ptr.Set( aDevice.GetProperty( KDlnaCap ) );

        if( ptr.Find( KAudioUpload ) != KErrNotFound )        

            {

            __LOG( "Audio upload supported!" );

            dev->SetAudioUpload( ETrue );

            }

        if( ptr.Find( KImageUpload ) != KErrNotFound )

            {

            __LOG( "Image upload supported!" );

            dev->SetImageUpload( ETrue );

            }

        if( ptr.Find( KVideoUpload ) != KErrNotFound )

            {

            __LOG( "Video upload supported!" );

            dev->SetVideoUpload( ETrue );

            }

        if( ptr.Find( KCreateChildContainer ) != KErrNotFound )

            {

            __LOG( "Create child container supported!" );

            dev->SetCreateChildContainer( ETrue );

            }        

        }   

    if( aDevice.DeviceType().Find( KMediaServer ) != KErrNotFound )

        {

        dev->SetDeviceType( CUpnpAVDevice::EMediaServer );

        }

    else

        {

        dev->SetDeviceType( CUpnpAVDevice::EMediaRenderer );

        }

    dev->SetFriendlyNameL( aDevice.DescriptionProperty( KFriendlyName ) );

    dev->SetUuidL( aDevice.Uuid() );   

    dev->SetLocal( aDevice.Local() );

    ParseDeviceServicesL( aDevice, *dev );

    CleanupStack::Pop( dev );

    iDevices.Append( dev );

    }

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

// CUPnPDeviceRepository::AddProtocolInfoL

// See upnpdevicerepository.h

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

CUpnpAVDeviceExtended& CUPnPDeviceRepository::AddProtocolInfoL(

    const TDesC8& aUuid, const TDesC8& aSource, const TDesC8& aSink )

    {

    __LOG( "CUPnPDeviceRepository::AddProtocolInfoL" );

    // Find the device

    TInt count = iDevices.Count();

    CUpnpAVDeviceExtended* dev = NULL;

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

        {

        if( iDevices[ i ]->Uuid() == aUuid )

            {

            dev = iDevices[ i ];

            i = count;

            }

        }

    if( dev )

        {

        if( dev->DeviceType() == CUpnpAVDevice::EMediaServer )

            {

            dev->SetSourceProtocolInfoL( aSource );

            dev->SetSinkProtocolInfoL( aSink );

            dev->SetCapabilitiesBySupportedMimeTypesL( aSource );

            }

        else

            {

            dev->SetSourceProtocolInfoL( aSource );

            dev->SetSinkProtocolInfoL( aSink );

            dev->SetCapabilitiesBySupportedMimeTypesL( aSink );    

            }

        dev->SetPInfoReceived( ETrue );        

        }

    else

        {

        User::Leave( KErrNotFound );

        }    

    return *dev;

    }

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

// CUPnPDeviceRepository::Remove

// See upnpdevicerepository.h

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

void CUPnPDeviceRepository::Remove( const TDesC8& aUuid )

    {

    __LOG( "CUPnPDeviceRepository::Remove" );

    TInt count = iDevices.Count();

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

        {

        if( iDevices[ i ]->Uuid() == aUuid )

            {

            delete iDevices[ i ];

            iDevices.Remove( i );

            i = count;

            }

        }

    }

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

// CUPnPDeviceRepository::FindDeviceL

// See upnpdevicerepository.h

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

CUpnpAVDeviceExtended& CUPnPDeviceRepository::FindDeviceL(

    const TDesC8& aUuid )

    {

    __LOG( "CUPnPDeviceRepository::FindDeviceL" );

    CUpnpAVDeviceExtended* tmp = NULL;

    TInt count = iDevices.Count();

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

        {

        if( iDevices[ i ]->Uuid() == aUuid )

            {

            tmp = iDevices[ i ];

            i = count;

            }

        }

    if( !tmp )

        {

        __LOG( "FindDeviceL - not found" );

        User::Leave( KErrNotFound );

        }

    return *tmp;    

    }

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

// CUPnPDeviceRepository::DeviceList

// See upnpdevicerepository.h

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

const RPointerArray<CUpnpAVDeviceExtended>&

    CUPnPDeviceRepository::DeviceList() const

    {

    __LOG( "CUPnPDeviceRepository::DeviceList" );

    return iDevices;

    }

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

// CUPnPDeviceRepository::SubscribeDeviceL

// See upnpdevicerepository.h

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

void CUPnPDeviceRepository::SubscribeDeviceL( const TDesC8& aUuid )

    {

    __LOG( "CUPnPDeviceRepository::SubscribeDeviceL" );

    __LOG8( aUuid );

    // Find the device and increase subscription count/check if we have

    // subscribed already

    TInt count = iDevices.Count();

    TInt subscriptionCount = KErrNotFound;

    TInt index;

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

        {

        if( aUuid.Compare( iDevices[ index ]->Uuid() ) == 0 )

            {

            subscriptionCount = iDevices[ index ]->IncreaseSubscriptionCount();

            index = count;

            }

        }

    if( subscriptionCount == KFirstSubscription )

        {

        __LOG( "SubscribeDeviceL - First subscription" ); 

        // Start subsciption for AVTransport and RenderingControl services

        // Find the device

        const RPointerArray<CUpnpDevice>& devList =

            iControlPoint.DeviceList();

        count = devList.Count();

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

            {

            if( aUuid.Compare( devList[ index ]->Uuid() ) == 0 )

                {

                break;

                }

            }

        // Find the AVTransport service and subscribe

        RPointerArray<CUpnpService>& servList =

            devList[ index ]->ServiceList();

        count = servList.Count();

        CUpnpService* tempService = NULL;

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

            {

            if( servList[ index ]->ServiceType().Find(

                KAVTransportService ) >= 0 )

                {

                tempService = servList[ index ];

                index = count;

                }

            }

        if( tempService && iIsWlanActive )

            {

            // AVTransport service found for the device, subscribe

            __LOG( "SubscribeDeviceL - Subscribe for AVTransport" ); 

            iControlPoint.SubscribeL( tempService ); 

            }

        else

            {     

            // Service not found, can't subscribe

            __LOG( "SubscribeDeviceL - AVTransport service not found" );

            }

        tempService = NULL;

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

            {

            if( servList[ index ]->ServiceType().Find(

                KRenderingControlService ) >= 0 )

                {

                tempService = servList[ index ];

                index = count;

                }

            }

        if( tempService && iIsWlanActive )

            {

            // RenderingControl service found for the device, subscribe

            __LOG( "SubscribeDeviceL - Subscribe for RenderingControl" ); 

            iControlPoint.SubscribeL( tempService ); 

            }

        else

            {     

            // Service not found, can't subscribe

            __LOG( "SubscribeDeviceL - RenderingControl service not found" );

            }                    

        }

    else if( subscriptionCount == KErrNotFound ) 

        {

        __LOG( "SubscribeDeviceL - device not found" );

        }

    else

        {

        // Subscribed already, do nothing

        __LOG( "SubscribeDeviceL - Subscription done already, ignoring!" ); 

        }        

    }

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

// CUPnPDeviceRepository::UnSubscribeDeviceL

// See upnpdevicerepository.h

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

void CUPnPDeviceRepository::UnSubscribeDeviceL( const TDesC8& aUuid )

    {

    __LOG( "CUPnPDeviceRepository::UnSubscribeDeviceL" );

    __LOG8( aUuid );

    // Find the device and decrease subscription count/check if it's needed

    // to unsubscribe

    TInt count = iDevices.Count();

    TInt subscriptionCount = KErrNotFound;

    TInt index;

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

        {

        if( aUuid.Compare( iDevices[ index ]->Uuid() ) == 0 )

            {

            subscriptionCount = 

                iDevices[ index ]->DecreaseSubscriptionCount();

            index = count;

            }

        }    

    if( subscriptionCount == 0 )

        {   

        // Start unsubsciption for AVTransport and RenderingControl services

        // Find the device

        const RPointerArray<CUpnpDevice>& devList =

            iControlPoint.DeviceList();

        count = devList.Count();

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

            {

            if( aUuid.Compare( devList[ index ]->Uuid() ) == 0 )

                {

                break;

                }

            }

        // Find the AVTransport service and unsubscribe

        RPointerArray<CUpnpService>& servList =

            devList[ index ]->ServiceList();

        count = servList.Count();

        CUpnpService* tempService = NULL;

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

            {

            if( servList[ index ]->ServiceType().Find(

                KAVTransportService ) >= 0 )

                {

                tempService = servList[ index ];

                index = count;

                }

            }

        if( tempService && iIsWlanActive )

            {

            // AVTransport service found for the device, unsubscribe

            __LOG( "UnSubscribeDeviceL - UnSubscribe AVTransport" ); 

            iControlPoint.UnsubscribeL( tempService ); 

            }

        else

            {     

            // Service not found, can't unsubscribe

            __LOG( "UnSubscribeDeviceL - AVTransport service not found" );

            }

        tempService = NULL;

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

            {

            if( servList[ index ]->ServiceType().Find(

                KRenderingControlService ) >= 0 )

                {

                tempService = servList[ index ];

                index = count;

                }

            }

        if( tempService && iIsWlanActive )

            {

            // RenderingControl service found for the device, subscribe

            __LOG( "UnSubscribeDeviceL - UnSubscribe RenderingControl" ); 

            iControlPoint.UnsubscribeL( tempService ); 

            }

        else

            {     

            // Service not found, can't subscribe

            __LOG( "UnSubscribeDeviceL - RenderingControl service not\

found" );

            }                    

        }

    else if( subscriptionCount == KErrNotFound ) 

        {

        __LOG( "UnSubscribeDeviceL - device not found" );

        }

    else

        {

        // No need to unsubscibe

        }           

    }

void CUPnPDeviceRepository::ConnectionLost()

    {

    __LOG( "CUPnPDeviceRepository::ConnectionLost" );

    iIsWlanActive = EFalse;

    iDevices.ResetAndDestroy();

    }

TBool CUPnPDeviceRepository::IsWlanActive()

    {

    __LOG1( "CUPnPDeviceRepository::IsWlanActive, %d", (TInt)iIsWlanActive );

    return iIsWlanActive;

    }

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

// CUPnPDeviceRepository::ParseDeviceServicesL

// See upnpdevicerepository.h

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

void CUPnPDeviceRepository::ParseDeviceServicesL( CUpnpDevice& aSource,

    CUpnpAVDeviceExtended& aTarget )

    {

    __LOG( "CUPnPDeviceRepository::ParseDeviceServicesL" );

    TBool createObjectSupported = EFalse;

    TBool getMuteSupported = EFalse;

    TBool setMuteSupported = EFalse;

    TBool getVolumeSupported = EFalse;

    TBool setVolumeSupported = EFalse;

    RPointerArray<CUpnpService>services = aSource.ServiceList();

    TInt i;

    TInt count = services.Count(); 

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

        {

        // Get max volume if it exists

        CUpnpStateVariable* volumeState = 

                services[ i ]->StateVariable( KVolume );

        // If volume info found, save it to the device

        if( volumeState )