/** @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:
*
*/


// INCLUDE FILES
#include "upnpssdphandlerup.h"
#include "upnpssdpserver.h"
#include "upnpmsearchtimer.h"

#define KLogFile _L("UPnPStack.txt")
#include "upnpcustomlog.h"

#include "upnpmessagehandler.pan"

// -----------------------------------------------------------------------------
// CUpnpSsdpHandlerUp::CUpnpSsdpHandlerUp
// -----------------------------------------------------------------------------
//
CUpnpSsdpHandlerUp::CUpnpSsdpHandlerUp(
                            MUpnpSsdpServerObserver& aSsdpServerObserver )
                            : CUpnpSsdpHandlerBase( aSsdpServerObserver )
    {
    }

// -----------------------------------------------------------------------------
// CUpnpSsdpHandlerUp::~CUpnpSsdpHandlerUp
// -----------------------------------------------------------------------------
//
CUpnpSsdpHandlerUp::~CUpnpSsdpHandlerUp()
   {
   ClearTimers();
   delete iSsdpServer;
   delete iMulticastSsdpServer;
   }

// -----------------------------------------------------------------------------
// CUpnpSsdpHandlerUp::CUpnpSsdpHandlerUp
// -----------------------------------------------------------------------------
//
CUpnpSsdpHandlerUp* CUpnpSsdpHandlerUp::NewL(
                              MUpnpSsdpServerObserver& aSsdpServerObserver )
    {
    CUpnpSsdpHandlerUp* self = new ( ELeave )
                               CUpnpSsdpHandlerUp( aSsdpServerObserver );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CUpnpSsdpHandlerUp::ConstructL
// -----------------------------------------------------------------------------
//
void CUpnpSsdpHandlerUp::ConstructL()
    {
    }

// -----------------------------------------------------------------------------
// CUpnpSsdpHandlerUp::StartL
// -----------------------------------------------------------------------------
//
void CUpnpSsdpHandlerUp::StartL( RSocketServ& aSocketServ )
    {
    if ( !iSsdpServer || !iMulticastSsdpServer )
        {
        delete iSsdpServer;
        iSsdpServer = NULL;
        iSsdpServer = CUpnpSsdpServer::NewL( &iSsdpServerObserver,
                                             &aSocketServ,
                                             KDefaultStartPort );

        delete iMulticastSsdpServer;
        iMulticastSsdpServer = NULL;
        iMulticastSsdpServer = CUpnpSsdpServer::NewL( &iSsdpServerObserver,
                                                      &aSocketServ,
                                                      KDefaultMulticastPort,
                                                      iSsdpServer );
        }
    iSsdpServer->StartL();
    iMulticastSsdpServer->StartL();
    }

// -----------------------------------------------------------------------------
// CUpnpSsdpHandlerUp::Stop
// -----------------------------------------------------------------------------
//
void CUpnpSsdpHandlerUp::Stop()
    {
    __ASSERT_DEBUG( iSsdpServer && iMulticastSsdpServer,
        User::Panic( KMessageHandler, EMessageHandlerBadState ) );
    ClearTimers();
    iSsdpServer->Stop();
    iMulticastSsdpServer->Stop();
    }

// -----------------------------------------------------------------------------
// CUpnpSsdpHandlerUp::AddressChangeL
// -----------------------------------------------------------------------------
//     
void CUpnpSsdpHandlerUp::AddressChangeL( TInetAddr& aAddress )
    {
    iSsdpServer->AddressChangedL( aAddress );
    iMulticastSsdpServer->AddressChangedL( aAddress );  
    }
    
// -----------------------------------------------------------------------------
// CUpnpSsdpHandlerUp::SsdpSearchL
// -----------------------------------------------------------------------------
//
void CUpnpSsdpHandlerUp::SsdpSearchL( const TDesC8& aSearchString, TDesC8& aMX )
    {
    __ASSERT_DEBUG( iSsdpServer && iMulticastSsdpServer,
        User::Panic( KMessageHandler, EMessageHandlerBadState ) );

    if ( iCPCounter == 0 )
        {
        for (TInt i(0); i < iTimers.Count(); i++ )
            {
            CUpnpMSearchTimer* timer = iTimers[i];
            iTimers.Remove( i );
            delete timer;
            }
        return;
        }

    TBuf8<KMXTimeBuffer> time;

    CUpnpMSearchTimer* timer = CUpnpMSearchTimer::NewLC( this, aSearchString, aMX );
    iTimers.AppendL( timer );
    CleanupStack::Pop(timer);

    TInt mx = timer->GetNextValue();
    TInt t = timer->GetNextValue();
    if ( mx > 0 )
        {
        time.Num(mx);
        iSsdpServer->SearchL( const_cast<TDesC8&>( aSearchString ), time );
        }
    if ( t > 0 )
        {
        t = t * KSecond;
        ( iTimers[( iTimers.Count() - 1 )] )->Start( t );
        }
    else
        {
        iTimers.Remove( iTimers.Count() - 1 );
        delete timer;
        }
    }

// -----------------------------------------------------------------------------
// CUpnpSsdpHandlerUp::AddLocalControlPoint
// -----------------------------------------------------------------------------
//
TInt CUpnpSsdpHandlerUp::AddLocalControlPoint( )
    {
    return iCPCounter++;
    }

// -----------------------------------------------------------------------------
// CUpnpSsdpHandlerUp::RemoveLocalControlPoint
// -----------------------------------------------------------------------------
//
TInt CUpnpSsdpHandlerUp::RemoveLocalControlPoint( )
    {
    iCPCounter--;
    __ASSERT_ALWAYS( iCPCounter >= 0,
        User::Panic( KMessageHandler, EMessageHandlerRemoveNonExistingCp ) );
    return iCPCounter;
    }


// -----------------------------------------------------------------------------
// CUpnpSsdpHandlerUp::AdvertiseDeviceL
// -----------------------------------------------------------------------------
//
void CUpnpSsdpHandlerUp::AdvertiseDeviceL( TInt aLive,  CUpnpDeviceLibraryElement& aElement )
    {
    LOGSH( 0, "CUpnpMessageHandlerEngine::AdvertiseDeviceL");

    __ASSERT_DEBUG( iSsdpServer && iMulticastSsdpServer,
        User::Panic( KMessageHandler, EMessageHandlerBadState ) );
    // forward advertisement requests to ssdp server
    // depending on the element status, advertise ssdp:alive or ssdp:byebye

    LOGSH( 0, "MESSAGE HANDLER ENGINE ADVERTISING");

    if ( aLive )
        {
        iSsdpServer->AdvertiseAliveL( aElement );
        }
    else
        {
        iSsdpServer->AdvertiseByebyeL( aElement );
        }
    }

// -----------------------------------------------------------------------------
// CUpnpSsdpHandlerUp::TimerEventL
// Callback function
// -----------------------------------------------------------------------------
//
void CUpnpSsdpHandlerUp::TimerEventL( CUpnpNotifyTimer* aTimer )
    {
    if ( !(aTimer->iStatus == KErrNone) )
        {
        return;
        }

    TInt i(0);
    if ( !iCPCounter )
        {
        for (; i < iTimers.Count(); i++ )
            {
            CUpnpMSearchTimer* timer = iTimers[i];
            iTimers.Remove( i );
            delete timer;
            }
        return;
        }

    for (; i < iTimers.Count(); i++ )
        {
        if ( iTimers[i] == aTimer )
            {
            break;
            }
        }
    if (i < iTimers.Count() )
        {
        TBuf8<KMXTimeBuffer> time;

        TInt mx = iTimers[i]->GetNextValue();
        TInt t = iTimers[i]->GetNextValue();
        if ( mx > 0 )
            {
            time.Num( mx );
            TPtrC8 ptr = iTimers[i]->GetTarget();
            iSsdpServer->SearchL(ptr, time);
            }
        if ( t > 0 )
            {
            t = t * KSecond;
            ( iTimers[( iTimers.Count() - 1 )])->Start( t );
            }
        else
            {
            CUpnpMSearchTimer* timer = iTimers[i];
            iTimers.Remove(i);
            delete timer;
            }
        }
    }

// -----------------------------------------------------------------------------
// CUpnpSsdpHandlerUp::ClearTimers
// -----------------------------------------------------------------------------
//
void CUpnpSsdpHandlerUp::ClearTimers()
    {
    for ( TInt i(0); i < iTimers.Count(); i++ )
        {
        iTimers[i]->Cancel();
        }
    iTimers.ResetAndDestroy();
    }

// -----------------------------------------------------------------------------
// CUpnpSsdpHandlerUp::IsStarted
// -----------------------------------------------------------------------------
//
TBool CUpnpSsdpHandlerUp::IsStarted()
    {
    return ( iSsdpServer && iMulticastSsdpServer );
    }

// End of File