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

*

*/

// INCLUDE FILES

#include "upnpstatevariable.h"

#include "upnpstring.h"

#include "upnpargument.h"

#include "upnpserviceimplementation.h"

#define KLogFile _L("UPnPStack.txt")

#include "upnpcustomlog.h"

// logs

#include "f32file.h" 

#include "s32file.h"

// CONSTANTS

_LIT8(KUi1, "ui1");

_LIT8(KUi2, "ui2");

_LIT8(KUi4, "ui4");

_LIT8(KI1, "i1");

_LIT8(KI2, "i2");

_LIT8(KI4, "i4");

_LIT8(KInt, "int");

_LIT8(KR4, "r4");

_LIT8(KR8, "r8");

_LIT8(KNumber, "number");

_LIT8(KFixed144, "fixed.14.4");

_LIT8(KFloat, "float");

_LIT8(KChar, "char");

_LIT8(KString, "string");

_LIT8(KDate, "date");

_LIT8(KDateTime, "dateTime");

_LIT8(KDateTimeTz, "dateTime.tz");

_LIT8(KTime, "time");

_LIT8(KTimeTz, "time.tz");

_LIT8(KBoolean, "boolean");

_LIT8(KBinBase64, "bin.base64");

_LIT8(KBinHex, "bin.hex");

_LIT8(KUri, "uri");

_LIT8(KUuid, "uuid");

//_LIT8(KDataType, "dataType");

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

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

// CUpnpStateVariable::CUpnpStateVariable

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CUpnpStateVariable::CUpnpStateVariable()

{

}

void CUpnpStateVariable::ConstructL()

    {

    iName = HBufC8::NewL(0);

    iDataType = HBufC8::NewL(0);

  //  iDefaultValue = HBufC8::NewL(0);

    iRangeMin = HBufC8::NewL(0);

    iRangeMax = HBufC8::NewL(0);

    iRangeStep = HBufC8::NewL(0);

    iValue = HBufC8::NewL(0);

    iEventable = HBufC8::NewL(0);

    iParent = NULL;

    iMaxEventRate = 0;

    iCurrentEventTime = 0; 

    iReadyForEventing = ETrue;

    }

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

// CUpnpStateVariable::NewL

// Two-phased constructor.

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

//

CUpnpStateVariable* CUpnpStateVariable::NewL()

{

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

    self->ConstructL();

    return self;

}

// Destructor

CUpnpStateVariable::~CUpnpStateVariable()

{

    delete iName;

    delete iDataType;

    delete iDefaultValue;

    delete iRangeMin;

    delete iRangeMax;

    delete iRangeStep;

    delete iEventable;

    iAllowedValueList.ResetAndDestroy();

    iAllowedValueList.Close();

    delete iValue;

}

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

// CUpnpStateVariable::Name

//

// (other items were commented in a header).

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

//

EXPORT_C const TPtrC8 CUpnpStateVariable::Name()

{

    if ( iName )

    {

        return *iName;

    }

    else

    {

        return KNullDesC8();

    }

}

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

EXPORT_C void CUpnpStateVariable::SetNameL( const TDesC8& aName)

    {

    HBufC8* tmp = aName.AllocL();

    delete iName;

    iName = tmp;

    }

// CUpnpStateVariable::Value

//

// (other items were commented in a header).

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

//

EXPORT_C const TPtrC8 CUpnpStateVariable::Value()

{

    LOGS("CUpnpStateVariable::Value()");

    if ( iValue )

    {

        return *iValue;

    }

    else

    {

        return KNullDesC8();

    }

}

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

// CUpnpStateVariable::SetValueL

//

// (other items were commented in a header).

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

//

EXPORT_C void CUpnpStateVariable::SetValueL(const TDesC8& aValue, TBool aIsModerated)

{

    LOGS("CUpnpStateVariable::SetValueL(const TDesC8&)");

    if( iValue )

    {

        delete iValue; 

        iValue = NULL;

    }

    iValue = aValue.AllocL();

    iModerated = aIsModerated;

    if (iParent)

    {

        iParent->AddEventVariable(*this, aIsModerated);

    }

}

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

// CUpnpStateVariable::SetValueL

//

// (other items were commented in a header).

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

//

EXPORT_C void CUpnpStateVariable::SetValueL(TInt aValue, TBool aIsModerated)

{

 //   LOGS("CUpnpStateVariable::SetValueL(TInt)");

    TBuf8<10> num;

    num.Num(aValue);

    SetValueL( num, aIsModerated );

}

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

// CUpnpStateVariable::Eventable

//

// (other items were commented in a header).

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

//

EXPORT_C const TPtrC8 CUpnpStateVariable::Eventable()

{

    if ( iEventable )

    {

        return *iEventable;

    }

    else

    {

        return KNullDesC8();

    }

}

EXPORT_C  void CUpnpStateVariable::SetEventableL(const TDesC8& aEventable)

    {

    HBufC8* tmp = aEventable.AllocL();

    delete iEventable;

    iEventable = tmp;

    }

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

// CUpnpStateVariable::GetDefaultValue

//

// (other items were commented in a header).

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

//

EXPORT_C void CUpnpStateVariable::GetDefaultValue(TInt& aValue)

{

    if ( iDefaultValue )

    {

        TLex8 lex( *iDefaultValue );

        TInt err = lex.Val( aValue );

        // Check conversion result

        if( err != KErrNone )

                aValue = err;

    }

    else

    {

        aValue = KErrNotFound;

    }

}

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

// CUpnpStateVariable::DefaultValue

//

// (other items were commented in a header).

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

//

EXPORT_C const TPtrC8 CUpnpStateVariable::DefaultValue()

{

    if ( iDefaultValue )

    {

        return *iDefaultValue;

    }

    else

    {

        return KNullDesC8();

    }

}

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

// CUpnpStateVariable::AllowedValuesLC

//

// (other items were commented in a header).

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

//

EXPORT_C CDesC8Array* CUpnpStateVariable::AllowedValuesLC()

{

    CDesC8ArrayFlat* values = new (ELeave) CDesC8ArrayFlat(1);

    CleanupStack::PushL(values);

    for ( TInt index = 0; index < iAllowedValueList.Count(); index++ )

    {

        HBufC8* tmp = iAllowedValueList[index];

        values->AppendL( *tmp );

    }

    return values;

}

EXPORT_C void CUpnpStateVariable::AddAllowedValueL( const TDesC8& aAllowedValue )

    {

    iAllowedValueList.Append( aAllowedValue.AllocL() );

    }

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

// CUpnpStateVariable::MaxValue

//

// (other items were commented in a header).

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

//

EXPORT_C TInt CUpnpStateVariable::MaxValue()

{

    TInt retValue = KErrNotFound;

    if ( iRangeMax )

    {

        TLex8 lex( *iRangeMax );

        lex.Val( retValue );

    }

    return retValue;    

}

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

// CUpnpStateVariable::MinValue

//

// (other items were commented in a header).

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

//

EXPORT_C TInt CUpnpStateVariable::MinValue()

{

    TInt retValue = KErrNotFound;

    if ( iRangeMin )

    {

        TLex8 lex( *iRangeMin );

        lex.Val( retValue );

    }

    return retValue; 

}

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

// CUpnpStateVariable::Step

//

// (other items were commented in a header).

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

//

EXPORT_C TInt CUpnpStateVariable::Step()

{

    TInt retValue = KErrNotFound;

    if ( iRangeStep )

    {

        TLex8 lex( *iRangeStep );

        lex.Val( retValue );

    }

    return retValue; 

}

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

// CUpnpStateVariable::Type

//

// (other items were commented in a header).

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

//

EXPORT_C TArgumentType CUpnpStateVariable::Type()

{

    if ( iDataType )

    {

        const TPtrC8 value = *iDataType;

        if (value == KUi1())

        {

            return EUi1;

        }

        else if (value ==KUi2())

        {

            return EUi2;

        }

        else if (value ==KUi4())

        {

            return EUi4;

        }  

        else if (value ==KI1())

        {

            return EI1;

        }

        else if (value ==KI2())

        {

            return EI2;

        }

        else if (value ==KI4())

        {

            return EI4;

        }

        else if (value ==KInt())

        {

            return EInt;        

        }

        else if (value ==KR4())

        {

            return ER4;

        }

        else if (value ==KR8())

        {

            return ER8;

        }

        else if (value ==KNumber())

        {

            return ENumber;

        }

        else if (value ==KFixed144())

        {

            return EFixed144;

        }

        else if (value ==KFloat())

        {

            return EFloat;

        }

        else if (value ==KChar())

        {

            return EChar;

        }

        else if (value ==KString())

        {

            return EString;

        }   

        else if (value ==KDate())

        {

            return EDate;

        }

        else if (value ==KDateTime())

        {

            return EDateTime;

        }

        else if (value ==KDateTimeTz())

        {

            return EDateTimeTz;

        }

        else if (value ==KTime())

        {

            return ETime;

        }

        else if (value ==KTimeTz())

        {

            return ETimeTz;

        }

        else if (value ==KBoolean())

        {

            return EBoolean;

        }

        else if (value ==KBinBase64())

        {

            return EBinBase64;

        }

        else if (value ==KBinHex())

        {

            return EBinHex;

        }

        else if (value ==KUri())

        {

            return EUri;

        }

        else if (value ==KUuid())

        {

            return EUuid;

        }

        else

        {

        }

    }

    return EUnknown;

}

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

// CUpnpStateVariable::SetParentImplementation

//

// (other items were commented in a header).

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

//

void CUpnpStateVariable::SetParentImplementation(CUpnpServiceImplementation &aParent)

{

    iParent = &aParent;

}

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

// CUpnpStateVariable::SetParentImplementation

//

// (other items were commented in a header).

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

//

TBool CUpnpStateVariable::IsModerated()

{

    return iModerated;

}

EXPORT_C void CUpnpStateVariable::SetTypeL(const TDesC8& aType)

    {

    HBufC8* tmp = aType.AllocL();

    delete iDataType;

    iDataType = tmp;

    }

TBool CUpnpStateVariable::ReadyForEventing()

{

    return iReadyForEventing;

}       

void CUpnpStateVariable::SetMaxEventRate(TInt aMaxRate, TInt aNormalRate)

{

    iMaxEventRate = aMaxRate;

    iReadyForEventing = ETrue;

    iCurrentEventTime = aMaxRate;

    iNormalEventRate = aNormalRate;

}

TInt CUpnpStateVariable::MaxEventRate()

{

    return iMaxEventRate;

}

void CUpnpStateVariable::EventTick()

{

    if(iMaxEventRate > 0)

    {

        iCurrentEventTime = iCurrentEventTime + iNormalEventRate;

        if(iCurrentEventTime >= iMaxEventRate)

        {

                iReadyForEventing = ETrue;

                iCurrentEventTime = 0;

                iEventTime.UniversalTime();

        }

        else

        {

                iTime.UniversalTime();

                TInt64 int64(iMaxEventRate);

                TInt64 diffTime((iTime.MicroSecondsFrom(iEventTime)).Int64());