/*
* Copyright (c) 2003-2005 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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:       Implementation for common LIW classes to be used both
*                consumer and provider side.
*
*/






#include "liwcommon.h"
#include <eikenv.h>
const TInt KInitialMaxProviders = 0xff;

CLiwCriteriaItem::CLiwCriteriaItem()
    {
    }



EXPORT_C CLiwCriteriaItem* CLiwCriteriaItem::NewL()
    {
    CLiwCriteriaItem* item = new (ELeave) CLiwCriteriaItem();
    CleanupStack::PushL( item );
    item->ConstructL();
    CleanupStack::Pop(item); // item
    return item;
    }



EXPORT_C CLiwCriteriaItem* CLiwCriteriaItem::NewLC()
    {
    CLiwCriteriaItem* item = new (ELeave) CLiwCriteriaItem();
    CleanupStack::PushL( item );
    item->ConstructL();
    return item;
    }



EXPORT_C CLiwCriteriaItem* CLiwCriteriaItem::NewL(
    TInt aCriteriaId,
    TInt aServiceCmd,
    const TDesC8& aContentType)
    {
    CLiwCriteriaItem* item = new (ELeave) CLiwCriteriaItem();
    CleanupStack::PushL( item );
    item->ConstructL(aCriteriaId, aServiceCmd, aContentType);
    CleanupStack::Pop(item); // item
    return item;
    }



EXPORT_C CLiwCriteriaItem* CLiwCriteriaItem::NewLC(
    TInt aCriteriaId,
    TInt aServiceCmd,
    const TDesC8& aContentType)
    {
    CLiwCriteriaItem* item = new (ELeave) CLiwCriteriaItem();
    CleanupStack::PushL( item );
    item->ConstructL(aCriteriaId, aServiceCmd, aContentType);
    return item;    
    }

EXPORT_C CLiwCriteriaItem* CLiwCriteriaItem::NewL(       
                                    TInt aCriteriaId,
                                    const TDesC8& aServiceCmd,
                                    const TDesC8& aContentType)
    {
    CLiwCriteriaItem* item = new (ELeave) CLiwCriteriaItem();
    CleanupStack::PushL( item );
    item->ConstructL(aCriteriaId, aServiceCmd, aContentType);
    CleanupStack::Pop(item); // item
    return item;
    }

EXPORT_C CLiwCriteriaItem* CLiwCriteriaItem::NewLC(
                                TInt aCriteriaId,
                                const TDesC8& aServiceCmd,
                                const TDesC8& aContentType)
    {
    CLiwCriteriaItem* item = new (ELeave) CLiwCriteriaItem();
    CleanupStack::PushL( item );
    item->ConstructL(aCriteriaId, aServiceCmd, aContentType);
    return item;    
    }


EXPORT_C CLiwCriteriaItem::~CLiwCriteriaItem()
    {
    delete iReserved.iData.iBufC8; 
    delete iContentType;
    iOptions.Reset();
    
    iMetadataOptions.Reset();
    }


void CLiwCriteriaItem::ConstructL()
    {
    iMaxProviders = KInitialMaxProviders;
    }



void CLiwCriteriaItem::ConstructL(TInt aCriteriaId, TInt aServiceCmd,
    const TDesC8& aContentType)
    {
    iMaxProviders = KInitialMaxProviders;
	iCriteriaId = aCriteriaId;
    iServiceCmd = aServiceCmd;
    SetContentTypeL( aContentType );
    }

void CLiwCriteriaItem::ConstructL(TInt aCriteriaId, const TDesC8& aServiceCmd,
                                  const TDesC8& aContentType)
    {
    iMaxProviders = KInitialMaxProviders;
    iCriteriaId = aCriteriaId;
    SetServiceCmdL( aServiceCmd );
    SetContentTypeL( aContentType );
    }

EXPORT_C void CLiwCriteriaItem::SetId(TInt aId)
    {
    iCriteriaId = aId;      
    }



EXPORT_C void CLiwCriteriaItem::SetServiceClass(const TUid& aServiceUid)
    {
    iServiceClass = aServiceUid;
    }
    


EXPORT_C void CLiwCriteriaItem::SetServiceCmd(TInt aServiceCmd)
    {
    iServiceCmd = aServiceCmd;
    }

EXPORT_C void CLiwCriteriaItem::SetServiceCmdL(const TDesC8& aServiceCmd)
    {
    iServiceCmd = KLiwCmdAsStr;
    delete iReserved.iData.iBufC8;
    iReserved.iData.iBufC8 = NULL;
    iReserved.iData.iBufC8 = HBufC8::NewL(aServiceCmd.Length());
    TPtr8 content(iReserved.iData.iBufC8->Des());
    content.SetLength(aServiceCmd.Length());
    content.Copy(aServiceCmd);
    }

EXPORT_C void CLiwCriteriaItem::SetContentTypeL(const TDesC8& aContentType)
    {
    delete iContentType;
    iContentType = NULL;
    iContentType = HBufC8::NewL(aContentType.Length());
    TPtr8 content(iContentType->Des());
    content.SetLength(aContentType.Length());
    content.Copy(aContentType);
    }



EXPORT_C TInt CLiwCriteriaItem::Id() const
    {
    return iCriteriaId;
    }



EXPORT_C const TUid& CLiwCriteriaItem::ServiceClass() const
    {
    return iServiceClass;
    }
    


EXPORT_C TInt CLiwCriteriaItem::ServiceCmd() const
    {   
    return iServiceCmd;
    }

EXPORT_C const TDesC8& CLiwCriteriaItem::ServiceCmdStr() const
    {   
    return ((iReserved.iData.iBufC8) ? *iReserved.iData.iBufC8 : KNullDesC8());
    }

EXPORT_C const TDesC8& CLiwCriteriaItem::ContentType() const
    {
    if (iContentType)
        {
        return *iContentType;
        }

    return KNullDesC8();
    }



EXPORT_C void CLiwCriteriaItem::SetOptions(TUint aOptions)
    {
    if(aOptions == 0)
    	return;
    
    iOptions.Set(aOptions);
    }


EXPORT_C void CLiwCriteriaItem::SetMetaDataOptions(const TLiwVariant& aMetaDataOptions)
    {
    iMetadataOptions.SetL(aMetaDataOptions);
    }

EXPORT_C void CLiwCriteriaItem::GetMetaDataOptions(TLiwVariant& aMetaDataOptions) const
    {
    aMetaDataOptions.SetL(iMetadataOptions);
    }

EXPORT_C TUint CLiwCriteriaItem::Options() const
    {
    return iOptions.AsTUint();
    }



EXPORT_C void CLiwCriteriaItem::ReadFromResoureL(TResourceReader& aReader)
    {
    delete iContentType;
    iContentType = NULL;

    delete iReserved.iData.iBufC8;   
    iReserved.iData.iBufC8 = NULL;   
    
    iCriteriaId = aReader.ReadInt32();
    iServiceCmd = aReader.ReadInt32();

    if (iServiceCmd == KLiwCmdAsStr)   
      {
        TPtrC8 txtptr = aReader.ReadTPtrC8();
        iReserved.iData.iBufC8 = HBufC8::NewL(txtptr.Length());
        TPtr8 content(iReserved.iData.iBufC8->Des());
        content.Copy( txtptr );
      }

    {
      TPtrC8 txtptr = aReader.ReadTPtrC8();
      iContentType = HBufC8::NewL(txtptr.Length());
      TPtr8 content(iContentType->Des());
      content.Copy( txtptr );
    }

    iServiceClass = TUid::Uid(aReader.ReadInt32());

    iDefaultProvider = TUid::Uid(aReader.ReadInt32());

    iMaxProviders = aReader.ReadUint8();
    
    SetOptions((TUint)aReader.ReadUint8());
    
    TInt capResID = aReader.ReadInt32(); // Skip over reserved field.
    
    
    }



EXPORT_C TUid CLiwCriteriaItem::DefaultProvider() const
    {
    return iDefaultProvider;
    }



EXPORT_C void CLiwCriteriaItem::SetDefaultProvider(TInt aDefault)
    {
    iDefaultProvider = TUid::Uid(aDefault);
    }   


EXPORT_C TInt CLiwCriteriaItem::MaxProviders() const
    {
    return iMaxProviders;
    }


EXPORT_C void CLiwCriteriaItem::SetMaxProviders(TInt aMaxProviders)
    {
    iMaxProviders = aMaxProviders;
    }


EXPORT_C TBool CLiwCriteriaItem::operator==(const CLiwCriteriaItem& aItem)
    {
      if (iServiceCmd != KLiwCmdAsStr) 
        {
          return ((iCriteriaId                                  == aItem.iCriteriaId)           &&
                  (iServiceCmd                                  == aItem.iServiceCmd)           &&
                  (iContentType->Compare(*(aItem.iContentType)) == KErrNone)                    &&
                  (iServiceClass.iUid                           == aItem.iServiceClass.iUid)    &&
                  (iDefaultProvider.iUid                        == aItem.iDefaultProvider.iUid) &&
                  (iMaxProviders                                == aItem.iMaxProviders)         &&
                  (iOptions                                     == aItem.iOptions)				&&       
                  (iMetadataOptions                             == aItem.iMetadataOptions));       
        }
      else
        {
        	if(iCriteriaId== aItem.iCriteriaId)
        	{
        		if(0 == iReserved.iData.iBufC8->Des().Compare(aItem.iReserved.iData.iBufC8->Des()))
        		{
        			if(iContentType->Compare(*(aItem.iContentType)) == KErrNone)
        			{
        				if(iServiceClass.iUid == aItem.iServiceClass.iUid)
        				{
        					if(iDefaultProvider.iUid == aItem.iDefaultProvider.iUid)
        					{
        						if(iMaxProviders == aItem.iMaxProviders)
        						{
        							if((iOptions == aItem.iOptions))
        							{
        								if((iMetadataOptions == aItem.iMetadataOptions))
        								{
        									return ETrue;
        								}
        							}
        						}
        					}
        				}
        			}
        		}
        	}
           	return EFalse;
        }
    }

EXPORT_C TInt32 MLiwNotifyCallback::GetTransactionID()
{
	TTime currentTime;
	const TInt KMin = 60;
	const TInt KSec = 60;
	const TInt KMcSec = 1000;
	currentTime.HomeTime();
	return	 (KMin * KSec * currentTime.DateTime().Hour())+ 
			 (KMin * currentTime.DateTime().Minute())+
			 (KMcSec * currentTime.DateTime().Second()) + 
			 (currentTime.DateTime().MicroSecond());
}
// End of file