// Copyright (c) 2002-2009 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:

 //

 #include "t_property.h"

 class CPropBroadcastSlave : public CBase

 	{

 public:

 	static TInt LoopThreadEntry(TAny*);

 	CPropBroadcastSlave(CPropBroadcast* aProg, TUid aCategory, TUint aMasterKey, TUint aSlaveKey);

 	void Create(TThreadPriority);

 	void Delete();

 	void Loop();

 	CPropBroadcast*	iProg;

 	TUid			iCategory;

 	TUint			iMasterKey;

 	TUint			iSlaveKey;

 	RProperty				iProp;

 	RThread					iThread;

 	TRequestStatus			iStatus;

 	CPropBroadcastSlave*	iNext;

 	};

 CPropBroadcastSlave::CPropBroadcastSlave(CPropBroadcast* aProg, TUid aCategory, TUint aMasterKey, TUint aSlaveKey) : 

 		iProg(aProg), iCategory(aCategory), iMasterKey(aMasterKey), iSlaveKey(aSlaveKey)

 	{

 	}

 void CPropBroadcastSlave::Create(TThreadPriority aPrio)

 	{

 	TInt r = iProp.Define(iCategory, iSlaveKey, RProperty::EInt, KPassPolicy, KPassPolicy);

 	TF_ERROR_PROG(iProg, r, r == KErrNone);

 	r = iProp.Attach(iCategory, iSlaveKey);

 	TF_ERROR_PROG(iProg, r, r == KErrNone);

 	r = iThread.Create(KNullDesC, LoopThreadEntry, 0x2000, NULL, this);

 	TF_ERROR_PROG(iProg, r, r == KErrNone);

 	iThread.Logon(iStatus);

 	iThread.SetPriority(aPrio);

 	iThread.Resume();

 	}

 void CPropBroadcastSlave::Delete()

 	{

 	iThread.Kill(EExitKill);

 	iThread.Close();

 	User::WaitForRequest(iStatus);

 	TF_ERROR_PROG(iProg, iStatus.Int(), iStatus.Int() == EExitKill);

 	TInt r = iProp.Delete(iCategory, iSlaveKey);

 	TF_ERROR_PROG(iProg, r, r == KErrNone);

 	iProp.Close();

 	delete this;

 	}

 TInt CPropBroadcastSlave::LoopThreadEntry(TAny* ptr)

 	{

 	CPropBroadcastSlave* self = (CPropBroadcastSlave*) ptr;

 	self->Loop();

 	return KErrNone;

 	}

 void CPropBroadcastSlave::Loop()

 	{

 	RProperty mProp;

 	TInt r = mProp.Attach(iCategory, iMasterKey, EOwnerThread);

 	TF_ERROR_PROG(iProg, r, r == KErrNone);

 	RProperty sProp;

 	r = sProp.Attach(iCategory, iSlaveKey, EOwnerThread);

 	TF_ERROR_PROG(iProg, r, r == KErrNone);

 	TInt value = 1;

 	for(;;)

 		{

 		TRequestStatus status;

 		mProp.Subscribe(status);

 		r = sProp.Set(value);

 		TF_ERROR_PROG(iProg, r, r == KErrNone);

 		User::WaitForRequest(status);

 		r = mProp.Get(value);

 		TF_ERROR_PROG(iProg, r, r == KErrNone);

 		}

 	}

 _LIT(KPropBroadcastName, "RProperty Broadcast");

 CPropBroadcast::CPropBroadcast(TUid aCategory, TUint aMasterKey, 

 								TUint aSlaveKeySlot, TUint aSlaveCount, TUint aFirstHighPriority) : 

 	  CTestProgram(KPropBroadcastName), iCategory(aCategory), iMasterKey(aMasterKey), 

 		  iSlaveKeySlot(aSlaveKeySlot), iSlaveCount(aSlaveCount), iFirstHighPriority(aFirstHighPriority)

 	{

 	}

 void CPropBroadcast::Run(TUint aCount)

 	{

 	RProperty mProp;

 	TInt r = mProp.Define(iCategory, iMasterKey, RProperty::EInt, KPassPolicy, KPassPolicy);

 	TF_ERROR(r, r == KErrNone);

 	r = mProp.Attach(iCategory, iMasterKey);

 	TF_ERROR(r, r == KErrNone);

 	for (TUint j = 0; j < iSlaveCount; ++j)

 		{

 		CPropBroadcastSlave* slave = new CPropBroadcastSlave(this, iCategory, iMasterKey, iSlaveKeySlot + j);

 		slave->Create((j < iFirstHighPriority) ? EPriorityLess : EPriorityMore);

 		slave->iNext = iSlaveList;

 		iSlaveList = slave;

 		}

 	for (TUint i = 1; i < aCount; ++i)

 		{

 		CPropBroadcastSlave* slave = iSlaveList;

 		while (slave)

 			{

 			TRequestStatus status;

 			slave->iProp.Subscribe(status);

 			TInt value;

 			r = slave->iProp.Get(value);

 			TF_ERROR(r, r == KErrNone);

 			if (value == (TInt) i)

 				{

 				slave->iProp.Cancel();

 				}

 			User::WaitForRequest(status);

 			TF_ERROR(status.Int(), (status.Int() == KErrCancel) || (status.Int() == KErrNone));

 			r = slave->iProp.Get(value);

 			TF_ERROR(r, r == KErrNone);

 			TF_ERROR(value, value == (TInt) i);

 			slave = slave->iNext;

 			}

 		mProp.Set(i + 1);

 		}

 	for (;;)

 		{

 		CPropBroadcastSlave* slave = iSlaveList;

 		if (slave == NULL) break;

 		iSlaveList = slave->iNext;

 		slave->Delete();

 		}

 	mProp.Delete(iCategory, iMasterKey);

 	mProp.Close();

 	}