/** @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:  Declares ServiceInfi class.

*

*/

// INCLUDE FILES

#include <e32base.h>

#include <e32cons.h>

#include "upnpdevice.h"

#include "upnpserviceinfo.h"

#include "upnpcontrolpoint.h"

#include "upnpcommonupnplits.h"

#include "upnpgenamessagefactory.h"

#undef  KLogFile

#define KLogFile _L("UPnPCP.txt")

#include "upnpcustomlog.h"

using namespace UpnpHTTP;

static const TInt KSubscriptionRenewalTimeWindow = 3;

static const TInt KSubscriptionRenewalMinimalTime = 6;

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

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

// CUpnpAction::NewLC

// Two-phased constructor.

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

//

CUpnpServiceInfo* CUpnpServiceInfo::NewLC(

                            CUpnpControlPoint* aControlPoint,

                            CUpnpService* aService )

    {

    CUpnpServiceInfo* self = new (ELeave) CUpnpServiceInfo(

                                aControlPoint,

                                aService );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CUpnpServiceInfo::ConstructL

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

//

void CUpnpServiceInfo::ConstructL()

    {

    iResubscribeTimer = CUpnpNotifyTimer::NewL( this );

    }

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

// CUpnpServiceInfo::CUpnpServiceInfo

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

//

CUpnpServiceInfo::CUpnpServiceInfo( CUpnpControlPoint* aControlPoint,

                                    CUpnpService* aService ):

        iService( aService ),

        iControlPoint( aControlPoint ),

        iTimeOut( CUpnpControlPoint::KDefaultSubscriptionTimeout )

    {

    }

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

// CUpnpServiceInfo::~CUpnpServiceInfo

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

//

CUpnpServiceInfo::~CUpnpServiceInfo()

    {

    delete iResubscribeTimer;

    delete iSid;

    }

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

// CUpnpServiceInfo::TimerEventL

// Callback function

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

//

void CUpnpServiceInfo::TimerEventL( CUpnpNotifyTimer* /*aTimer*/ )

    {

    ResubscribeL();

    }

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

// CUpnpServiceInfo::StartTimerL

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

//

void CUpnpServiceInfo::StartTimerL( const TDesC8& aTimeout )

    {

    if ( aTimeout.FindC( KSeconds() ) != KErrNotFound )

        {

        TLex8 lex( aTimeout );

        static const TInt KLengthOfWordSecondMinus = 7;

        lex.Inc( KLengthOfWordSecondMinus );

        TInt tOutValue;

        TInt err( lex.Val( tOutValue ) );

        User::LeaveIfError( err );

        iTimeOut = tOutValue;

        }

    else

        {

        iTimeOut =

             CUpnpControlPoint::KDefaultSubscriptionTimeout ;

        }

//prevention from too frequent subscriptions

    if ( iTimeOut < KSubscriptionRenewalMinimalTime )

        {

        iTimeOut = KSubscriptionRenewalMinimalTime;

        }

    iResubscribeTimer->AfterSeconds(

        iTimeOut - KSubscriptionRenewalTimeWindow);

    }

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

// CUpnpServiceInfo::SessionId

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

//

TInt CUpnpServiceInfo::SessionId()

    {

    return iSessionId;

    }

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

// CUpnpServiceInfo::Service

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

//

CUpnpService* CUpnpServiceInfo::Service()

    {

    return iService;

    }

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

// CUpnpServiceInfo::Sid

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

//

const TDesC8& CUpnpServiceInfo::Sid() const

    {

    if ( iSid )

        {

        return *iSid;

        }

    else

        {

        return KNullDesC8;

        }

    }

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

// CUpnpServiceInfo::SetSidL

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

//

void CUpnpServiceInfo::SetSidL( const TDesC8& aSid )

    {

    delete iSid;

    iSid = NULL;

    iSid = aSid.AllocL();

    }

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

// CUpnpServiceInfo::SetSeq

// Sets sequence

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

//

void CUpnpServiceInfo::SetSeq( TUint32 aSeq )

    {

    iSeq = aSeq;

    }

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

// CUpnpServiceInfo::Seq

//

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

//

TUint32 CUpnpServiceInfo::Seq() const

    {

    return iSeq;

    }

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

// CUpnpServiceInfo::CreateSubscribtionMessageL

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

//

CUpnpGenaMessage* CUpnpServiceInfo::CreateSubscriptionMessageL(

                                                     THTTPMsgType aType)

    {

    return CreateSubscriptionMessageL( *iSid, aType );

    }

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

// CUpnpServiceInfo::CreateSubscribtionMessageL

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

//

CUpnpGenaMessage* CUpnpServiceInfo::CreateSubscriptionMessageL(

                                        const TDesC8& aPath, THTTPMsgType aType)

    {

    CUpnpGenaMessage* result = NULL;

    TBuf8<UpnpString::KMaxIntLength> timeoutBuf;

    timeoutBuf.Num( iTimeOut );

    CUpnpDevice& device = iService->Device();

    TInetAddr servAddress = iService->Address();

    TPtrC8 subscribe = iService->SubscriptionUrl();

    // check if path is not absolute

    if( subscribe.Find( KHttp() ) == 0 )

        {

        subscribe.Set( subscribe.Mid( KHttp().Length() ) );

        TInt slashPos = subscribe.Find( UpnpString::KSlash() );

        if( slashPos != KErrNotFound )

            {

            servAddress    = iControlPoint->GiveAddressL( subscribe.Left( slashPos ));

            subscribe.Set( subscribe.Mid( slashPos ) );

            }

        }

    switch( aType )

        {

        case ESubscription:

            {

            result = RUpnpGenaMessageFactory::SubscribeL(

                            subscribe, servAddress, aPath, timeoutBuf );

            }

        case EResubscription:

            {

            result = RUpnpGenaMessageFactory::ResubscribeL(

                            subscribe, servAddress, aPath, timeoutBuf );

            }

        case EUnSubscription:

            {

            result = RUpnpGenaMessageFactory::UnsubscribeL(

                            subscribe, servAddress, aPath);

            }

        default:

            {

            // Undefined. Should not come here at all!

            User::Leave(KErrArgument);

            break;

            }

        }

    if(result == NULL)

        {

        // To avoid Coverity FORWARD_NULL errors

        User::Leave(KErrArgument);

        }

    result->SetType( aType );

    iSessionId = result->SessionId();

    return result;

    }

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

// CUpnpServiceInfo::ResubscribeL

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

//

void CUpnpServiceInfo::ResubscribeL()

    {

    LOGS( "CUpnpServiceInfo::ResubscribeL - start" );

    iControlPoint->ResubscribeL( this );

    LOGS( "CUpnpServiceInfo::ResubscribeL - end" );

    }

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

// CUpnpServiceInfo::ConstructSubscribtionPathLC

//

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

//

HBufC8* CUpnpServiceInfo::ConstructSubscribtionPathLC( const TDesC8& aPath,

                                     TInetAddr& aAddr )

    {

    TBuf8<UpnpString::KMaxAddrOutputLength> addrBuf;

    CUpnpHttpMessage::AddrOutput( aAddr, addrBuf );

    TBuf<UpnpString::KMaxIntLength> port;

    port.Num( aAddr.Port() );

    HBufC8* longPath = HBufC8::NewLC(

        1 + KHTTPUrl().Length() +   // "<"

        addrBuf.Length() + 1 +      // ":"

        port.Length() + 1 +         // "\"

        aPath.Length() + 1 +        // "\"

        aPath.Length() + 1 );       // ">"

    TPtr8 longPathPtr( longPath->Des() );

    longPathPtr.Append( KLessThan8() );

    longPathPtr.Append( KHTTPUrl() );

    longPathPtr.Append( addrBuf );

    longPathPtr.Append( UpnpString::KColon() );

    longPathPtr.Append( port );

    longPathPtr.Append( UpnpString::KSlash() );

    longPathPtr.Append( aPath );

    longPathPtr.Append( UpnpString::KSlash() );

    longPathPtr.Append( aPath );

    longPathPtr.Append( KGreaterThan8() );

    return longPath;

    }

//end of file