// Copyright (c) 2008-2009 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 <e32base.h>

#include <c32comm.h>

#include <c32root.h>

#include <es_sock.h>

#include <comms-infras/es_commsdataobject.h>

#include <connpref.h>

#include <CommDbConnPref.h>

#include <metadatabase.h>

#include <commsdattypeinfov1_1.h>

#include <comms-infras/connectionqueryset.h>

#include <comms-infras/ss_commsdataobject.h>

#include <ecom/ecom.h>

#include "queryconnsettingstiermgrimpl.h"

#include "noddyqueryconnsettingsimpl.h"

using namespace ESock;

void Test0cL()

	{

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

	// Creating the query

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

	XConnectionQuerySet* querySet = XConnectionQuerySet::NewL();

	CleanupDeletePushL(querySet);

	XConnectionQueryBase* query;

	query = XText8Query::NewL(CommsDat::KCDTIdPortName, *querySet);

	query = XText16Query::NewL(CommsDat::KCDTIdNifName, *querySet);

	query = XText16Query::NewL(CommsDat::KCDTIdTsyName, *querySet);

	query = XBoolQuery::NewL(CommsDat::KCDTIdIpAddrFromServer, *querySet);

	query = XUintQuery::NewL(CommsDat::KCDTIdLastSessionClosedTimeout, *querySet);

	query = XBoolQuery::NewL(CommsDat::KCDTIdIfPromptForAuth, *querySet);

	CleanupStack::PopAndDestroy(querySet);

	}

void Test1L()

	{

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

	// Creating the query

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

	XConnectionQuerySet* querySet = XConnectionQuerySet::NewL();

	CleanupDeletePushL(querySet);

	XConnectionQueryBase* query;

	query = XText8Query::NewL(CommsDat::KCDTIdPortName, *querySet);

	query = XText16Query::NewL(CommsDat::KCDTIdNifName, *querySet);

	query = XText16Query::NewL(CommsDat::KCDTIdTsyName, *querySet);

	query = XBoolQuery::NewL(CommsDat::KCDTIdIpAddrFromServer, *querySet);

	query = XUintQuery::NewL(CommsDat::KCDTIdLastSessionClosedTimeout, *querySet);

	query = XBoolQuery::NewL(CommsDat::KCDTIdIfPromptForAuth, *querySet);

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

	// Serialisation/Deserialisation Test

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

	CConnectionQuerySet* cdo = CConnectionQuerySet::NewL(querySet);

	CleanupStack::Pop(querySet);

	CleanupStack::PushL(cdo);

	TInt length = cdo->Length();

	HBufC8* buffer = HBufC8::NewLC(length);

	if (!buffer) 

		{

		User::Leave(KErrNoMemory);

		}

	TPtr8 storePtr(buffer->Des());

	TInt ret = cdo->Store(storePtr);

	User::LeaveIfError(ret);

	// Load using Load()

	TPtrC8 loadPtr = buffer->Des();

	CConnectionQuerySet* outputContainer = CConnectionQuerySet::LoadL(loadPtr);

	delete outputContainer;

	CleanupStack::PopAndDestroy(buffer);

	CleanupStack::PopAndDestroy(cdo);

	}

void Test3L()

	{

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

	// Creating the query

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

	CNoddyQueryConnSettingsImpl* impl = new (ELeave)CNoddyQueryConnSettingsImpl();

	CleanupStack::PushL(impl);

	XConnectionQuerySet* querySet = XConnectionQuerySet::NewL();

	CleanupDeletePushL(querySet);

	XConnectionQueryBase* query;

	query = XText8Query::NewL(CommsDat::KCDTIdPortName, *querySet);

	query = XText16Query::NewL(CommsDat::KCDTIdNifName, *querySet);

	query = XBoolQuery::NewL(CommsDat::KCDTIdIpAddrFromServer, *querySet);

	query = XUintQuery::NewL(CommsDat::KCDTIdLastSessionClosedTimeout, *querySet);

	query = XIntQuery::NewL(CommsDat::KCDTIdIfPromptForAuth, *querySet);

	querySet->DispatchL(static_cast<MQueryConnSettingsApiExt*>(impl), NULL);

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

	// Testing the iterators

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

	TConnectionQueryIter iter1(querySet->GetQueryIter(XConnectionQueryBase::ENotAnswered));

	TInt count = 0;

	query = NULL;

	query = iter1++;

	while (query) 

		{

		count++;

		query = iter1++;;

		}

	ASSERT(count == 1);

	TConnectionQueryIter iter2(querySet->GetQueryIter(XConnectionQueryBase::EAnswered));

	count = 0;

	query = NULL;

	query = iter2++;

	while (query) 

		{

		count++;

		query = iter2++;

		}

	ASSERT(count == 4);

	CleanupStack::PopAndDestroy(querySet);

	CleanupStack::PopAndDestroy(impl);

	}

void Test4L()

	{

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

	// Creating the query

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

	CQueryConnSettingsTierMgrImpl* impl = CQueryConnSettingsTierMgrImpl::NewL(1);

	CleanupStack::PushL(impl);

	XConnectionQuerySet* querySet = XConnectionQuerySet::NewL();

	CleanupDeletePushL(querySet);

	XConnectionQueryBase* query;

	query = XUintQuery::NewL(CommsDat::KCDTIdIAPRecord | CommsDat::KCDTIdRecordTag, *querySet);

	query = XText16Query::NewL(CommsDat::KCDTIdIAPRecord | CommsDat::KCDTIdRecordName, *querySet);

	query = XUintQuery::NewL(CommsDat::KCDTIdIAPLocation, *querySet);

	query = XText8Query::NewL(CommsDat::KCDTIdPortName, *querySet);

	query = XText16Query::NewL(CommsDat::KCDTIdNifName, *querySet);

	query = XBoolQuery::NewL(CommsDat::KCDTIdIpAddrFromServer, *querySet);

	query = XUintQuery::NewL(CommsDat::KCDTIdLastSessionClosedTimeout, *querySet);

	query = XIntQuery::NewL(CommsDat::KCDTIdIfPromptForAuth, *querySet);

	querySet->DispatchL(static_cast<MQueryConnSettingsApiExt*>(impl), NULL);

	TBuf8<200> des8;

	TBuf16<200> des16;

	TBool b;

	TInt i(0x0F0F0F0F);

	TUint32 ui(0xF0F0F0F0);

	TInt count = 0;

	// Option 1 - Iterate through the query results

	TConnectionQueryIter iter (querySet->GetQueryIter(XConnectionQueryBase::EAnswered));

	const XConnectionQueryBase* qBase = iter++;

	while (qBase) 

		{

		count++;

		// Do something with query/data

		switch (qBase->Type()) 

			{

			case XConnectionQueryBase::EInt:

				{

				const XIntQuery* qInt = static_cast<const XIntQuery*>(qBase);

				i = qInt->Data();

				}

				break;

			case XConnectionQueryBase::EUint:

				{

				const XUintQuery* qUInt = static_cast<const XUintQuery*>(qBase);

				ui = qUInt->Data();

				}

				break;

			case XConnectionQueryBase::EBool:

				{

				const XBoolQuery* qBool = static_cast<const XBoolQuery*>(qBase);

				b = qBool->Data();

				}

				break;

			case XConnectionQueryBase::EText8:

				{

				const XText8Query* qText8 = static_cast<const XText8Query*>(qBase);

				des8 = qText8->Data();

				}

				break;

			case XConnectionQueryBase::EText16:

				{

				const XText16Query* qText16 = static_cast<const XText16Query*>(qBase);

				des16 = qText16->Data();

				}

				break;

			}

		qBase = iter++;

		}

	CleanupStack::PopAndDestroy(querySet);

	CleanupStack::PopAndDestroy(impl);

	}

/*

void Test4L()

	{

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

	// Creating the query

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

	XConnectionQuerySet* querySet = XConnectionQuerySet::NewL();

	CleanupDeletePushL(querySet);

	XConnectionQueryBase* query;

	query = XText8Query::NewL(CommsDat::KCDTIdPortName, *querySet);

	query = XText16Query::NewL(CommsDat::KCDTIdNifName, *querySet);

	query = XText16Query::NewL(CommsDat::KCDTIdTsyName, *querySet);

	query = XBoolQuery::NewL(CommsDat::KCDTIdIpAddrFromServer, *querySet);

	query = XUintQuery::NewL(CommsDat::KCDTIdLastSessionClosedTimeout, *querySet);

	query = XBoolQuery::NewL(CommsDat::KCDTIdIfPromptForAuth, *querySet);

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

	// Testing Find Query/Setting Data/Answered

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

	XText8Query* text8Query;

	text8Query = static_cast<XText8Query*>(querySet->FindQuery(CommsDat::KCDTIdPortName));

//	text8Query->SetData(_L8("oddlength"));

//	text8Query->SetQueryAnswered();

	XText16Query* textQuery;

	textQuery = static_cast<XText16Query*>(querySet->FindQuery(CommsDat::KCDTIdNifName));

//	textQuery->SetData(_L("Testing.nif"));

//	textQuery->SetQueryAnswered();

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

	// Serialisation/Deserialisation Test 2 (with some populated data)

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

	TInt length = queryContainer->Length();

	HBufC8* buffer = HBufC8::NewLC(length);

	if (!buffer) 

		{

		User::Leave(KErrNoMemory);

		}

	TInt ret;

	TPtr8 storePtr(buffer->Des());

	ret = queryContainer->Store(storePtr);

	User::LeaveIfError(ret);

	CParameterSetContainer* outputContainer = CParameterSetContainer::NewL();

	TPtrC8 loadPtr(buffer->Des());

	outputContainer->Load(loadPtr);

	delete outputContainer;

	CleanupStack::PopAndDestroy(buffer);

	CleanupStack::PopAndDestroy(queryContainer);

	}

*/	

void Test5L()

	{

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

	// Creating the query

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

	XConnectionQuerySet* querySet = XConnectionQuerySet::NewL();

	CleanupDeletePushL(querySet);

	XConnectionQueryBase* query;

	query = XText8Query::NewL(CommsDat::KCDTIdPortName, *querySet);

	query = XText16Query::NewL(CommsDat::KCDTIdNifName, *querySet);

	query = XText16Query::NewL(CommsDat::KCDTIdTsyName, *querySet);

	query = XText16Query::NewL(CommsDat::KCDTIdPortName, *querySet);

	query = XBoolQuery::NewL(CommsDat::KCDTIdIpAddrFromServer, *querySet);

	query = XUintQuery::NewL(CommsDat::KCDTIdLastSessionClosedTimeout, *querySet);

	query = XBoolQuery::NewL(CommsDat::KCDTIdIfPromptForAuth, *querySet);

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

	// RConnection API additional method test

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

    TInt err;

    RSocketServ ss;

	err = ss.Connect();

	RConnection con;

	err = con.Open(ss);

	CConnectionQuerySet* cdo = CConnectionQuerySet::NewL(querySet);

	CleanupStack::Pop(querySet);

	CleanupStack::PushL(cdo);

	// This should fail with KErrNotReady since the connection hasn't been started

	err = con.GetParameters(*cdo);

	ASSERT(err == KErrNotReady);

	// This should succeed

	err = con.Start();

	err = con.GetParameters(*cdo);

	TBuf8<200> des8;

	TBuf16<200> des16;

	TBool b;

	TInt i(0x0F0F0F0F);

	TUint32 ui(0xF0F0F0F0);

	TInt count = 0;

	if (err == KErrNone)

		{

		XConnectionQuerySet& outputQuerySet = cdo->DataObject();

		// Option 1 - Iterate through the query results

		TConnectionQueryIter iter (outputQuerySet.GetQueryIter(XConnectionQueryBase::EAnswered));

		const XConnectionQueryBase* qBase = iter++;

		while (qBase) 

			{

			count++;

			// Do something with query/data

			switch (qBase->Type()) 

				{

				case XConnectionQueryBase::EInt:

					{

					const XIntQuery* qInt = static_cast<const XIntQuery*>(qBase);

					i = qInt->Data();

					}

					break;

				case XConnectionQueryBase::EUint:

					{

					const XUintQuery* qUInt = static_cast<const XUintQuery*>(qBase);

					ui = qUInt->Data();

					}

					break;

				case XConnectionQueryBase::EBool:

					{

					const XBoolQuery* qBool = static_cast<const XBoolQuery*>(qBase);

					b = qBool->Data();

					}

					break;

				case XConnectionQueryBase::EText8:

					{

					const XText8Query* qText8 = static_cast<const XText8Query*>(qBase);

					des8 = qText8->Data();

					}

					break;

				case XConnectionQueryBase::EText16:

					{

					const XText16Query* qText16 = static_cast<const XText16Query*>(qBase);

					des16 = qText16->Data();

					}

					break;

				}

			qBase = iter++;

			}

		// Option 2 - Get a query response directly

		const XConnectionQueryBase* directQuery;

		directQuery = outputQuerySet.FindQuery(CommsDat::KCDTIdIfNetworks); // wont be found

		directQuery = outputQuerySet.FindQuery(CommsDat::KCDTIdTsyName);

		}

	con.Stop();

    con.Close();

    ss.Close();

	CleanupStack::PopAndDestroy(cdo);

	querySet = NULL;

	}

// Secure variants much simpler

// For EKA2, just an E32Main and a MainL()

LOCAL_C void MainL()

/**

 * Secure variant

 * Much simpler, uses the new Rendezvous() call to sync with the client

 */

	{

    _LIT(KLddName, "ECOMM");

    _LIT(KPddName, "ECDRV");

    // Load device drivers

    User::LoadPhysicalDevice(KPddName);

    User::LoadLogicalDevice(KLddName);

	// self contained query set / container tests

	TInt err = KErrNone;

//	TRAP(err, Test0cL());

//	TRAP(err, Test1L());

	TRAP(err, Test3L());

	TRAP(err, Test4L());

	// using rconnection - full end-to-end

	TRAP(err, Test5L());

	REComSession::FinalClose();

   	}

GLDEF_C TInt E32Main()

/**

 * @return - Standard Epoc error code on process exit

 * Secure variant only

 * Process entry point. Called by client using RProcess API

 */

	{

	__UHEAP_MARK;

	CTrapCleanup* cleanup = CTrapCleanup::New();

	if(cleanup == NULL)

		{

		return KErrNoMemory;

		}

	TRAPD(err,MainL());

	delete cleanup;

	__UHEAP_MARKEND;

	return err;

    }