/** @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 storage for devices known by control point.
*
*/


// INCLUDE FILES

#include <e32base.h>

#include <upnpdevice.h>

#include "upnpcpbdevicerepository.h"
#include "upnpcpbdevicelistutils.h"

#define KLogFile _L("UPnPControlPoint.txt")
#include <upnpcustomlog.h>

static const TInt KDTargetDeviceTypesGranularity = 1;

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

// -----------------------------------------------------------------------------
// CUpnpCpbDeviceRepository::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CUpnpCpbDeviceRepository* CUpnpCpbDeviceRepository::NewL(const CDesC8Array& aTargetDeviceTypes)
    {
    LOG_FUNC_NAME;
    CUpnpCpbDeviceRepository* self = new (ELeave) CUpnpCpbDeviceRepository();

    CleanupStack::PushL(self);
    self->ConstructL(aTargetDeviceTypes);
    CleanupStack::Pop(self);

    return self;
    }

// -----------------------------------------------------------------------------
// CUpnpCpbDeviceRepository::~CUpnpCpbDeviceRepository
// C++ default destructor
// -----------------------------------------------------------------------------
//
CUpnpCpbDeviceRepository::~CUpnpCpbDeviceRepository()
    {
    LOG_FUNC_NAME;

    TInt i;
    // only root devices should be deleted
    // subdevices are removed from all lists
    for(i=(iDiscoveredDevices.Count());i;i--)
        {
        if ( iDiscoveredDevices[i-1]->IsEmbeddDevice() )
            {
            iDiscoveredDevices.Remove(i-1);
            }
        }

    for(i=(iUninterestingDevices.Count());i;i--)
        {
        if (iUninterestingDevices[i-1]->IsEmbeddDevice())
            {
            iUninterestingDevices.Remove(i-1);
            }
        }

    for(i=(iUnneededDevices.Count());i;i--)
        {
        if (iUnneededDevices[i-1]->IsEmbeddDevice())
            {
            iUnneededDevices.Remove(i-1);
           }
        }

    iDiscoveredDevices.ResetAndDestroy();
    iDiscoveredDevices.Close();

    iUninterestingDevices.ResetAndDestroy();
    iUninterestingDevices.Close();

    iUnneededDevices.ResetAndDestroy();
    iUnneededDevices.Close();

    iIncomliteRootDevices.ResetAndDestroy();
    iIncomliteRootDevices.Close();

    iIncomingDevices.ResetAndDestroy();
    iIncomingDevices.Close();

    // Delete target devices list
    if ( iTargetDeviceTypes )
        {
        iTargetDeviceTypes->Reset();
        delete iTargetDeviceTypes;
        }

    LOGS("CUpnpCpbDeviceRepository::CUpnpCpbDeviceRepository - END");
    }

// -----------------------------------------------------------------------------
// CUpnpCpbDeviceRepository::MatchTargetDevice
// Check if device match target types
// -----------------------------------------------------------------------------
//
TBool CUpnpCpbDeviceRepository::MatchTargetDevice(const TDesC8& aDeviceType )
    {
    TBool result = FALSE;
    if(iTargetDeviceTypes)
        {
        if((*iTargetDeviceTypes)[0].Find(_L8("*")) != KErrNotFound) 
            {
            result = TRUE;
            return result;
            }
        for(TInt i(0); i < iTargetDeviceTypes->Count(); i++)
            {
            if(aDeviceType.Find((*iTargetDeviceTypes)[i]) != KErrNotFound)
                {
                result = TRUE;
                break;
                }
            }
        }
    return result;
    }

// -----------------------------------------------------------------------------
// CUpnpCpbDeviceRepository::IsKnownDevice
// Check if device is in repository
// -----------------------------------------------------------------------------
//
TBool CUpnpCpbDeviceRepository::IsKnownDevice(const TDesC8& aDeviceUuid)
    {
    return (IsDiscoveredDevice(aDeviceUuid) || IsUninterestingDevice(aDeviceUuid)
                    || IsUnneededDevice(aDeviceUuid));
    }

// -----------------------------------------------------------------------------
// CUpnpCpbDeviceRepository::IsDiscoveredDevice
// Check if device is discovered already
// -----------------------------------------------------------------------------
//
TBool CUpnpCpbDeviceRepository::IsDiscoveredDevice(const TDesC8& aDeviceUuid)
    {
    return UpnpCpbDeviceListUtils::ExistOnList(aDeviceUuid, iDiscoveredDevices);
    }

// -----------------------------------------------------------------------------
// CUpnpCpbDeviceRepository::IsUninterestingDevice
// Check if device is discovered but type is not matching
// needed devices types
// -----------------------------------------------------------------------------
//
TBool CUpnpCpbDeviceRepository::IsUninterestingDevice(const TDesC8& aDeviceUuid)
    {
    return UpnpCpbDeviceListUtils::ExistOnList(aDeviceUuid, iUninterestingDevices);
    }

// -----------------------------------------------------------------------------
// CUpnpCpbDeviceRepository::IsUnneededDevice
// Check if device is unneded (type is different then needed).
// -----------------------------------------------------------------------------
//
TBool CUpnpCpbDeviceRepository::IsUnneededDevice(const TDesC8& aDeviceUuid)
    {
    return UpnpCpbDeviceListUtils::ExistOnList(aDeviceUuid, iUnneededDevices);
    }


// -----------------------------------------------------------------------------
// CUpnpCpbDeviceRepository::AddDiscoveredDeviceL
// Add device to discovered device list
// -----------------------------------------------------------------------------
//
TBool CUpnpCpbDeviceRepository::AddDiscoveredDeviceL(CUpnpDevice* aDevice)
    {
    return UpnpCpbDeviceListUtils::AddDeviceL(aDevice, iDiscoveredDevices);
    }

// -----------------------------------------------------------------------------
// CUpnpCpbDeviceRepository::AddUnnededDeviceL
// Add device to discovered device list
// -----------------------------------------------------------------------------
//
TBool CUpnpCpbDeviceRepository::AddUnneddedDeviceL(CUpnpDevice* aDevice)
    {
    return UpnpCpbDeviceListUtils::AddDeviceL(aDevice, iUnneededDevices);
    }

// -----------------------------------------------------------------------------
// CUpnpCpbDeviceRepository::AddIncompliteDeviceL
// Add device to discovered device list
// -----------------------------------------------------------------------------
//
TBool CUpnpCpbDeviceRepository::AddIncompliteDeviceL(CUpnpDevice* aDevice)
    {
    return UpnpCpbDeviceListUtils::AddDeviceL(aDevice, iIncomliteRootDevices);
    }


// -----------------------------------------------------------------------------
// CUpnpCpbDeviceRepository::AddIncomingDeviceL
// -----------------------------------------------------------------------------
//
TBool CUpnpCpbDeviceRepository::AddIncomingDeviceL( CUpnpDevice* aDevice )
    {
    CUpnpDevice* device = RemoveIncomingDevice( aDevice->Uuid() );
    if ( device )
        {
        delete device;
        }
    return UpnpCpbDeviceListUtils::AddDeviceL( aDevice, iIncomingDevices );
    }

// -----------------------------------------------------------------------------
// CUpnpCpbDeviceRepository::RemoveIncomingDeviceL
// -----------------------------------------------------------------------------
//
CUpnpDevice* CUpnpCpbDeviceRepository::RemoveIncomingDevice( const TDesC8& aUuid )
    {
    CUpnpDevice* res = NULL;
    for ( TInt i = 0; i < iIncomingDevices.Count(); i++ )
        {
        if ( iIncomingDevices[i]->Uuid().Compare( aUuid )  ==  0 )
            {
            res = iIncomingDevices[i];
            iIncomingDevices.Remove(i);
            break;
            }
        }
    return res;
    }



// -----------------------------------------------------------------------------
// CUpnpCpbDeviceRepository::AddUnnededDeviceL
// Add device to discovered device list
// -----------------------------------------------------------------------------
//
void CUpnpCpbDeviceRepository::AddDiscoveredDevicesL(RPointerArray<CUpnpDevice>& aDevices)
    {
    UpnpCpbDeviceListUtils::AddDevicesL(aDevices, iDiscoveredDevices);
    }

// -----------------------------------------------------------------------------
// CUpnpCpbDeviceRepository::AddUnnededDeviceL
// Add device to uninteresting device list
// -----------------------------------------------------------------------------
//
void CUpnpCpbDeviceRepository::AddUninterestingDevicesL(RPointerArray<CUpnpDevice>& aDevices)
    {
    UpnpCpbDeviceListUtils::AddDevicesL(aDevices, iUninterestingDevices);
    }

// -----------------------------------------------------------------------------
// CUpnpCpbDeviceRepository::AddUnnededDeviceL
// Add device to unneded device list
// -----------------------------------------------------------------------------
//
void CUpnpCpbDeviceRepository::AddUnneddedDevicesL(RPointerArray<CUpnpDevice>& aDevices)
    {
    UpnpCpbDeviceListUtils::AddDevicesL(aDevices, iUnneededDevices);
    }

// -----------------------------------------------------------------------------
// Return discovered device list
// -----------------------------------------------------------------------------
//
const RPointerArray<CUpnpDevice>& CUpnpCpbDeviceRepository::DiscoveredDeviceList() const
    {
    return iDiscoveredDevices;
    }

// -----------------------------------------------------------------------------
// Return discovered device list
// -----------------------------------------------------------------------------
//
const RPointerArray<CUpnpDevice>& CUpnpCpbDeviceRepository::UnneddedDeviceList() const
    {
    return iUnneededDevices;
    }

// -----------------------------------------------------------------------------
// Return discovered device list
// -----------------------------------------------------------------------------
//
const RPointerArray<CUpnpDevice>& CUpnpCpbDeviceRepository::UninterestingDeviceList() const
    {
    return iUninterestingDevices;
    }

// -----------------------------------------------------------------------------
// Return discovered device list
// -----------------------------------------------------------------------------
//
const RPointerArray<CUpnpDevice>& CUpnpCpbDeviceRepository::IncompliteDeviceList() const
    {
    return iIncomliteRootDevices;
    }

// -----------------------------------------------------------------------------
// CUpnpCpbDeviceRepository::FindIncompliteDevice
// Find incomplite device in repository
// -----------------------------------------------------------------------------
//
CUpnpDevice* CUpnpCpbDeviceRepository::FindIncompliteDevice(const TDesC8& aDeviceUuid)
    {
    CUpnpDevice* res = NULL;
    res = UpnpCpbDeviceListUtils::GetFromList(aDeviceUuid, iIncomliteRootDevices);
    return res;
    }

// -----------------------------------------------------------------------------
// CUpnpCpbDeviceRepository::FindDevice
// Find device in repository
// -----------------------------------------------------------------------------
//
CUpnpDevice* CUpnpCpbDeviceRepository::FindDevice(const TDesC8& aDeviceUuid)
    {
    CUpnpDevice* res = NULL;
    res = UpnpCpbDeviceListUtils::GetFromList(aDeviceUuid, iDiscoveredDevices);
    if(res)
        {
        return res;
        }
    res = UpnpCpbDeviceListUtils::GetFromList(aDeviceUuid, iUnneededDevices);
    if(res)
        {
        return res;
        }
    res = UpnpCpbDeviceListUtils::GetFromList(aDeviceUuid, iUninterestingDevices);
    if(res)
        {
        return res;
        }
    res = UpnpCpbDeviceListUtils::GetFromList(aDeviceUuid, iIncomliteRootDevices);
    if(res)
        {
        return res;
        }
    return res;
    }

// -----------------------------------------------------------------------------
// Finds root of given device among dicovered and being discovered devices
// -----------------------------------------------------------------------------
//
CUpnpDevice* CUpnpCpbDeviceRepository::FindRoot( const TDesC8& aDeviceUuid )
    {
    CUpnpDevice* res = NULL;
    res = UpnpCpbDeviceListUtils::GetRootFromList( aDeviceUuid, iDiscoveredDevices );
    if ( res )
        {
        return res;
        }
    res = UpnpCpbDeviceListUtils::GetRootFromList( aDeviceUuid, iUnneededDevices );
    if ( res )
        {
        return res;
        }
    res = UpnpCpbDeviceListUtils::GetRootFromList( aDeviceUuid, iUninterestingDevices );
    if ( res )
        {
        return res;
        }
    res = UpnpCpbDeviceListUtils::GetRootFromList( aDeviceUuid, iIncomliteRootDevices );
    if ( res )
        {
        return res;
        }
    return res;
    }

// -----------------------------------------------------------------------------
// CUpnpCpbDeviceRepository::RemoveDevice
// Remove device from all list
// -----------------------------------------------------------------------------
//
void CUpnpCpbDeviceRepository::RemoveDevice(CUpnpDevice* aDevice)
    {
    TInt i = iDiscoveredDevices.Find(aDevice);
    if (i !=KErrNotFound)
        {
        iDiscoveredDevices.Remove( i );
        }
    else
        {
        // check unneded device list
        i = iUnneededDevices.Find(aDevice);
        if ( i != KErrNotFound)
            {
            iUnneededDevices.Remove( i );
            }
        else
            {
            // check unninteresting device list
            i = iUninterestingDevices.Find(aDevice);
            if ( i != KErrNotFound)
                {
                iUninterestingDevices.Remove( i );
                }
            else
                {
                // check root devices with errors
                i = iIncomliteRootDevices.Find(aDevice);
                if ( i != KErrNotFound)
                    {
                    iIncomliteRootDevices.Remove( i );
                    }
                }
            }
        }
    }

// -----------------------------------------------------------------------------
// CUpnpCpbDeviceRepository::CUpnpCpbDeviceRepository
// Constructor
// -----------------------------------------------------------------------------
//
CUpnpCpbDeviceRepository::CUpnpCpbDeviceRepository()
    {
    LOG_FUNC_NAME;
    }

// -----------------------------------------------------------------------------
// CUpnpCpbDeviceRepository::ConstructL
// Second phase constructor
// -----------------------------------------------------------------------------
//
void CUpnpCpbDeviceRepository::ConstructL(const CDesC8Array& aTargetDeviceTypes)
    {
    LOG_FUNC_NAME;
    // coping target device
    iTargetDeviceTypes = new( ELeave ) CDesC8ArrayFlat( KDTargetDeviceTypesGranularity );
    for ( TInt i( 0 ); i < aTargetDeviceTypes.Count(); i++ )
        {
        iTargetDeviceTypes->AppendL( aTargetDeviceTypes[i]);
        }
    }

//  End of File