/** @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:  Defines the CUpnpDevice class

*

*/

// INCLUDE FILES

#include <e32math.h>

#include "upnpfileutils.h"

#include "upnpicon.h"

#include "upnpdevice.h"

#include "upnpcommonstructs.h"

#include "upnpstring.h"

#include "upnpdispatcher.h"

#include "upnpcons.h"

#include "upnpcommonupnplits.h"

#include "upnpcustomlog.h"

#include "upnpserviceimplementation.h"

#include "upnpdevicecontenthandler.h"

#define KLogFile _L("UPnPStack.txt")

// ============================= LOCAL FUNCTIONS ===============================

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

// CUpnpDevice::SetUuidL

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

//

void CUpnpDevice::SetUuidL( const TDesC8& aUUID )

    {

    HBufC8* tmp = aUUID.AllocL();

    delete iUUID;

    iUUID = tmp;

    }

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

// CUpnpDevice::AddDeviceL

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

//

void CUpnpDevice::AddDeviceL( CUpnpDevice* device )

    {

    device->SetRootDevice( EFalse );

    iDeviceList.AppendL( device );

    }

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

// CUpnpDevice::CUpnpDevice

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

//

CUpnpDevice::CUpnpDevice() :

    iExpired(ETrue), iNetworkType(EHomeNetwork), iIsRootDevice(ETrue)

    {

    }

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

// CUpnpDevice::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CUpnpDevice::ConstructL( const TUpnpDevice* aDevice,

    const RPointerArray<TUpnpService>& aServices )

    {

    Init();

    if ( aDevice )

        {

        iUUID = aDevice->iUUID.AllocL();

        iDeviceType = aDevice->iDeviceType.AllocL();

        iDescriptionURL = aDevice->iDescriptionURL.AllocL();

        iDomain = aDevice->iDomain.AllocL();

        iExpired = aDevice->iExpired;

        iAlive = aDevice->iAlive;

        if ( aDevice->iLocal )

            {

            iNetworkType = ELocalDevice;

            }

        else if ( aDevice->iRemote )

            {

            iNetworkType = ERemoteDevice;

            }

        else

            {

            iNetworkType = EHomeNetwork;

            }

        iServiceTypes = new (ELeave) CDesC8ArrayFlat( aServices.Count()

                == 0 ? 1 : aServices.Count() );

        for ( TInt i = 0; i < aServices.Count(); i++ )

            {

            iServiceTypes->AppendL( aServices[i]->iServiceType );

            }

        }

    }

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

// CUpnpDevice::NewL

// Two-phased constructor.

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

//

EXPORT_C CUpnpDevice* CUpnpDevice::NewL( const TUpnpDevice* aDevice,

        const RPointerArray<TUpnpService> & aServices

)

    {

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

    CleanupStack::PushL( self );

    self->ConstructL( aDevice, aServices );

    CleanupStack::Pop( self );

    return self;

    }

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

// CUpnpDevice::~CUpnpDevice

// Destructor.

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

//

CUpnpDevice::~CUpnpDevice()

    {

    iServiceDescriptionSessionIds.Reset();

    iServiceDescriptionSessionIds.Close();

    if ( iServiceTypes )

        {

        iServiceTypes->Reset();

        delete iServiceTypes;

        }

    if ( iServicesId )

        {

        iServicesId->Reset();

        delete iServicesId;

        }

    delete iUUID;

    delete iDeviceType;

    delete iDescriptionURL;

    delete iDomain;

    CleanupServiceArray();

    // destroy embedded devices

    iDeviceList.ResetAndDestroy();

    iDeviceList.Close();

    delete iClockSeq;

    iIcons.ResetAndDestroy();

    iIcons.Close();

    iServiceDescriptionSessionIds.Reset();

    iServiceDescriptionSessionIds.Close();

    iIconSessionIds.Reset();

    iIconSessionIds.Close();

    delete iUrlBase;

    iProperties.ResetAndDestroy();

    iProperties.Close();

    }

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

// CUpnpDevice::Init

// Initialisation.

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

//

void CUpnpDevice::Init()

    {

    iAddress = TInetAddr( INET_ADDR( 0,0,0,0 ), 0 );

    iIconReceiveState = EAllIconsAdded;

    }

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

// CUpnpDevice::CleanupServiceArray

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

//

void CUpnpDevice::CleanupServiceArray()

    {

    for ( TInt i = iServiceList.Count() - 1; i >= 0; --i )

        {

        delete iServiceList[ i ];

        iServiceList[ i ] = NULL;

        }

    iServiceList.Close();

    }

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

// CUpnpDevice::DescriptionUrl

// Return description URL.

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

//

EXPORT_C const TDesC8& CUpnpDevice::DescriptionUrl() const

    {

    if ( iDescriptionURL )

        {

        return *iDescriptionURL;

        }

    else

        {

        return KNullDesC8();

        }

    }

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

// CUpnpDevice::SetDescriptionUrlL

// Return description URL.

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

//

void CUpnpDevice::SetDescriptionUrlL( const TDesC8& aDescriptionUrl )

    {

    HBufC8* tmp = aDescriptionUrl.AllocL();

    delete iDescriptionURL;

    iDescriptionURL = tmp;

    }

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

// CUpnpDevice::SetAlive

// Set alive.

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

//

EXPORT_C void CUpnpDevice::SetAlive( TBool aAlive )

    {

    iAlive = aAlive;

    }

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

// CUpnpDevice::Expired

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

//

EXPORT_C TBool CUpnpDevice::Expired() const

    {

    return iExpired;

    }

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

// CUpnpDevice::SetExpired

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

//

EXPORT_C void CUpnpDevice::SetExpired( TBool aExpired )

    {

    iExpired = aExpired;

    }

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

// CUpnpDevice::DeviceType

// Return device type.

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

//

EXPORT_C const TPtrC8 CUpnpDevice::DeviceType()

    {

    if ( iDeviceType )

        {

        return TPtrC8( iDeviceType->Des() );

        }

    else

        {

        return KNullDesC8();

        }

    }

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

// CUpnpDevice::Uuid

// Return UUID.

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

//

EXPORT_C const TPtrC8 CUpnpDevice::Uuid()

    {

    if ( iUUID )

        {

        return TPtrC8( iUUID->Des() );

        }

    else

        {

        return KNullDesC8();

        }

    }

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

// CUpnpDevice::Alive

// Return iAlive.

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

//

EXPORT_C TBool CUpnpDevice::Alive() const

    {

    return iAlive;

    }

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

// CUpnpDevice::DescriptionUrlAddressL

// Return description URL address.

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

//

EXPORT_C TInetAddr CUpnpDevice::DescriptionUrlAddressL() const

    {

    if ( iAddress == TInetAddr( INET_ADDR( 0,0,0,0 ), 0) )

        {

        const TDesC8& url = DescriptionUrl();

        if ( url.Length()> KHttp().Length() )

            {

            TPtrC8 addrAndPath = url.Right( url.Length() - KHttp().Length() );

            TInt index = addrAndPath.Find( KSepar() );

            if ( index == KErrNotFound )

                {

                index = addrAndPath.Find( KSlash8() );

                }

            if ( index == KErrNotFound )

                {

                return TInetAddr( INET_ADDR( 0,0,0,0 ), 0 );

                }

            TPtrC8 addr = addrAndPath.Left( index );

            TInetAddr address;

            HBufC* addrBuf = HBufC::NewLC(addr.Length());

            addrBuf->Des().Copy(addr);

            address.Input(*addrBuf);

            CleanupStack::PopAndDestroy(addrBuf);

            return address;

            }

        return TInetAddr(INET_ADDR( 0,0,0,0 ), 0 );

        }

    return iAddress;

    }

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

// CUpnpDevice::DescriptionUrlPath

// Return description URL path.

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

//

EXPORT_C const TPtrC8 CUpnpDevice::DescriptionUrlPath() const

    {

    const TDesC8& url = DescriptionUrl();

    if ( url.Length()> KHttp().Length() )

        {

        TPtrC8 addrAndPath = url.Right( url.Length() - KHttp().Length() );

        TInt index = addrAndPath.Find( KSlash8() );

        if ( index != KErrNotFound )

            {

            TPtrC8 addr = addrAndPath.Right( addrAndPath.Length() - index );

            return addr;

            }

        }

    return TPtrC8( KNullDesC8 );

    }

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

// CUpnpDevice::DescriptionUrlPort

// Retrun description URL port.

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

//

EXPORT_C TInt CUpnpDevice::DescriptionUrlPort() const

    {

    if ( iAddress != TInetAddr( INET_ADDR( 0,0,0,0 ), 0) )

        {

        return iAddress.Port();

        }

    const TDesC8& url = DescriptionUrl();

    if ( url.Length()> KHttp().Length() )

        {

        TPtrC8 addrAndPath = url.Right( url.Length() - KHttp().Length() );

        TInt separIndex = addrAndPath.Find( KSepar() );

        if ( separIndex == KErrNotFound )

            {

            return KDefaultDescriptionUrlPort;

            }

        TInt slashIndex = addrAndPath.Find( KSlash8() );

        if ( slashIndex != KErrNotFound )

            {

            TPtrC8 port = addrAndPath.Mid(

                    separIndex + 1, slashIndex - separIndex

            );

            TLex8 lex( port );

            TInt prt;

            TInt err = lex.Val( prt );

            if( KErrNone != err )

                {

                return KErrNotFound;

                }

            return prt;

            }

        else

            {

            TPtrC8 port = addrAndPath.Right(

                    addrAndPath.Length() - ( separIndex + 1 )

            );

            TLex8 lex( port );

            TInt prt;

            TInt err = lex.Val( prt );

            if( KErrNone != err )

                {

                return KErrNotFound;

                }

            return prt;

            }

        }

    return KDefaultDescriptionUrlPort;

    }

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

// CUpnpDevice::ServiceTypesL

// Return service types.

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

//

EXPORT_C CDesC8Array& CUpnpDevice::ServiceTypesL()

    {

    if ( !iServiceTypes )

        {

        iServiceTypes = new (ELeave) CDesC8ArrayFlat( 2 );

        }

    return *iServiceTypes;

    }

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

// CUpnpDevice::FriendlyName

// Return friendly name.

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

//

EXPORT_C const TPtrC8 CUpnpDevice::DescriptionProperty( const TDesC8& aPropertyName )

    {

    TInt index = 0;

    while ( index < iProperties.Count() )

        {

        CUpnpDescriptionProperty* var = iProperties[index];

        if ( aPropertyName.Compare( var->Name() ) == KErrNone )

            {

            return var->Value();

            }

        index++;

        }

    return KNullDesC8();

    }

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

// CUpnpDevice::ServiceId

// Return service ID.

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

//

EXPORT_C const TPtrC8 CUpnpDevice::ServiceId( const TDesC8 &aServiceType )

    {

    //return Content( KServiceId(), aServiceType );

    for( TInt i(0); i < iServiceTypes->Count(); i++)

        {

        TInt pos =(*iServiceTypes)[i].Find( aServiceType );

        if( pos != KErrNotFound )

        return TPtrC8( ( *iServicesId )[i] );

        }

    return TPtrC8( (TUint8*)"", 0);

    }

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

// CUpnpDevice::ServiceDescriptionUrl

// Return service description URL.

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

//

EXPORT_C const TPtrC8 CUpnpDevice::ServiceDescriptionUrl( const TDesC8 &aServiceType )

    {

    for (TInt i=0;i<iServiceList.Count();i++)

        {

        if (!iServiceList[i]->ServiceType().Compare(aServiceType))

            {

            return iServiceList[i]->ServiceDescriptionUrl();

            }

        }

    return TPtrC8( (TUint8*)"", 0 );;

    }

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

// CUpnpDevice::ServiceList

// Return service list.

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

//

EXPORT_C RPointerArray<CUpnpService>& CUpnpDevice::ServiceList()

    {

    return iServiceList;

    }

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

// CUpnpDevice::DeviceList