/** @file

* Copyright (c) 2007-2007 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 simple device discovery process.

*

*/

// INCLUDE FILES

#include <e32base.h>

#include <upnpdevice.h>

#include "upnpcontenthandlerscontroller.h"

#include "upnpcpbsimpledevicedescription.h"

#include "upnpcpbhttpmessagecontroller.h"

#include "upnpcpbdevicerepository.h"

// LOGGER SETTINGS

#define KLogFile _L("UPnPControlPoint.txt")

#include <upnpcustomlog.h>

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

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

// CUpnpCpbSimpleDeviceDescription::NewL

// Two-phased constructor

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

//

CUpnpCpbSimpleDeviceDescription* CUpnpCpbSimpleDeviceDescription::NewL(

        MUpnpCpbHttpMessageController& aMessanger,

        CUpnpCpbDeviceRepository& aRepository)

    {

    LOG_FUNC_NAME;

    CUpnpCpbSimpleDeviceDescription* self =

        new (ELeave) CUpnpCpbSimpleDeviceDescription(aMessanger, aRepository);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// CUpnpCpbSimpleDeviceDescription::~CUpnpCpbSimpleDeviceDescription

// Destructor

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

//

CUpnpCpbSimpleDeviceDescription::~CUpnpCpbSimpleDeviceDescription()

    {

    LOG_FUNC_NAME;

    if(!iIsNull)

        {

        delete iRootDevice;

        }

    iRootDevice = NULL;

    }

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

// CUpnpCpbSimpleDeviceDescription::CUpnpCpbSimpleDeviceDescription

// Constructor

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

//

CUpnpCpbSimpleDeviceDescription::CUpnpCpbSimpleDeviceDescription(

        MUpnpCpbHttpMessageController& aMessanger,

        CUpnpCpbDeviceRepository& aRepository)

    : CUpnpCpbDeviceDescription(aMessanger, aRepository)

    {

    LOG_FUNC_NAME;

    }

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

// CUpnpCpbSimpleDeviceDescription::DiscoverDeviceL

// Start processing device.

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

//

TInt CUpnpCpbSimpleDeviceDescription::DiscoverDeviceL(CUpnpDevice* aDevice)

    {

    LOG_FUNC_NAME;

    iIsNull = EFalse;

    iRootDevice = aDevice;

    // check if device match the type

    if(!iRepository.MatchTargetDevice(aDevice->DeviceType()))

        {

        iResult = KDisscoveryFinished;

        return iResult;

        }

    iResult = KDisscoveryInProgress;

    TPtrC8 buffer(GetNextServiceType(iRootDevice));

    if (buffer.Length())

        {

        LOGS("CUpnpCpbSimpleDeviceDescription::DiscoverDeviceL - Discovering services");

        //ask for 1st service description

        iResult = KDisscoveryInProgress;

        TInt sessionId = iMessanger.GetServiceDescriptionL (aDevice, buffer);

        // put SessionID to memory per pending Service Description request

        aDevice->WaitServiceDescriptionL( sessionId );

        }

    else

        {

        LOGS("CUpnpCpbSimpleDeviceDescription::DiscoverDeviceL - "

             "No service info for the device");

        LOGS("CUpnpCpbSimpleDeviceDescription::DiscoverDeviceL - "

             "All device info brought - device officially discovered");

        iResult = KDisscoveryFinished;

        }

    return iResult;

    }

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

// CUpnpCpbSimpleDeviceDescription::ServiceDescription

// Function processing service description

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

//

TInt CUpnpCpbSimpleDeviceDescription::ServiceDescriptionL(CUpnpHttpMessage* aMsg)

    {

    LOG_FUNC_NAME;

    // Check if device is waiting for this service

    TBool waiting(EFalse);

    if(!iRootDevice)

        {

        iResult = KErrNotFound;

        }

    else

        {

        for( TInt servCount(0);

                servCount < iRootDevice->WaitServiceDescriptionCount(); servCount++)

            {

            if ( iRootDevice->WaitServiceDescriptionSessionId(servCount )

                     == aMsg->SessionId())

                {

                waiting = ETrue;

                break;

                }

            }

        // Waiting for service description

        if(waiting)

            {

            // Processing message

            if ( !aMsg->Is2xx())

                {

                LOGS("CUpnpCpbSimpleDeviceDescription::ServiceDescriptionL - "

                     "Wrong response recived.");

                iResult = KDisscoveryIncorrect;

                }

            else

                {

                iResult = ProcessServiceDescriptionL(aMsg);

                }

            }

        else

            {

            iResult = KErrNotFound;

            }

        }

    return iResult;

    }

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

// CUpnpCpbSimpleDeviceDescription::ServiceDescription

// Parse service description

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

//

TInt CUpnpCpbSimpleDeviceDescription::ProcessServiceDescriptionL(CUpnpHttpMessage* aMsg)

    {

    LOG_FUNC_NAME;

    CUpnpDevice::TServiceAdd result;

    // Parsing service desription

    CUpnpService* service = NULL;

    service = iSaxController->ParseServiceL(aMsg->Body(), iRootDevice);

    CleanupStack::PushL(service);

    result = iRootDevice->AddServiceL(aMsg->SessionId(), service);

    CleanupStack::Pop(service);

    if ( result == CUpnpDevice::EAllServicesAdded )

        { // device has received all service descriptions

        LOGS("CUpnpCpbSimpleDeviceDescription::ProcessServiceDescriptionL  - "

             "All service info added to the parent device");

        iResult = 	KDisscoveryFinished;

        }

    else if ( result == CUpnpDevice::EServiceAdded )

        {

        LOGS("CUpnpCpbSimpleDeviceDescription::ProcessServiceDescriptionL - "

             "Service added");

        // Waiting for next desciptions.

        iResult = 	KDisscoveryInProgress;

        TPtrC8 buffer(GetNextServiceType(iRootDevice));

        TInt sessionId = iMessanger.GetServiceDescriptionL (iRootDevice,

                                  buffer);

        // put SessionID to memory per pending Service Description request

        iRootDevice->WaitServiceDescriptionL( sessionId );

        }

    else

        {

        delete service;

        iResult = KDisscoveryInProgress;

        }

    LOGS1("CUpnpCpbSimpleDeviceDescription::ProcessServiceDescriptionL -res=%d", iResult);

    return iResult;

    }

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

// CUpnpCpbSimpleDeviceDescription::GetIncompliteRootDevice

//  Append discovered devices to array

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

//

CUpnpDevice* CUpnpCpbSimpleDeviceDescription::GetIncompliteRootDevice()

    {

    return NULL;

    }

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

// CUpnpCpbSimpleDeviceDescription::NullTargetDevice

// Constructor

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

//

void CUpnpCpbSimpleDeviceDescription::NullTargetDevice()

    {

    if (iResult == KDisscoveryFinished)

        {

        iIsNull = ETrue;

        }

    }

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

// CUpnpCpbSimpleDeviceDescription::NullTargetDevice

// Constructor

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

//

void CUpnpCpbSimpleDeviceDescription::DeleteTargetDevice()

    {

    if (!iIsNull || iResult == KDisscoveryIncorrect)

        {

        delete iRootDevice;

        }

    iRootDevice = NULL;

    }

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

// CUpnpCpbSimpleDeviceDescription::GetDiscoveredDeviceL

//  Append discovered devices to array

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

//

void CUpnpCpbSimpleDeviceDescription::GetDiscoveredDeviceL(

    RPointerArray<CUpnpDevice>& aArray, TBool /*aRemove*/ )

    {

    if (iRootDevice && iRepository.MatchTargetDevice(iRootDevice->DeviceType()))

        {

        if(iResult == KDisscoveryFinished)

            {

            aArray.AppendL(iRootDevice);

            }

        }

    }

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

// CUpnpCpbSimpleDeviceDescription::GetUninterestingDeviceL

//  Append not discovered (does not match the type) devices to array

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

//

void CUpnpCpbSimpleDeviceDescription::GetUninterestingDeviceL(

    RPointerArray<CUpnpDevice>& aArray, TBool /*aRemove*/ )

    {

    if (iRootDevice && !iRepository.MatchTargetDevice(iRootDevice->DeviceType()))

        {

        if (iResult == KDisscoveryFinished)

            {

            aArray.AppendL(iRootDevice);

            }

        }

    }

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

// CUpnpCpbSimpleDeviceDescription::GetUnnededDeviceL

//  Append discovered but not matching target types devices to array

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

//

void CUpnpCpbSimpleDeviceDescription::GetUnnededDeviceL(

    RPointerArray<CUpnpDevice>& /*aArray*/, TBool /*aRemove*/ )

    {

    // nothing to do, in case of simple device discovered are only matching type devices

    }

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

// CUpnpCpbSimpleDeviceDescription::FailedUuids

//  Returns incorrect uuids

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

//

const TPtrC8 CUpnpCpbSimpleDeviceDescription::FailedUuidsL()

    {

    if (iRootDevice)

        {

        return iRootDevice->Uuid();

        }

    else

        {

        return KNullDesC8();

        }

    }

//  End of File