--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/videoconnutility/connutility/inc/vcxconnutilwaitsch.h	Wed Sep 01 12:20:37 2010 +0100
@@ -0,0 +1,166 @@
+/*
+* Copyright (c) 2006 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:    CCVcxConnUtilWaitSch class declaration file*
+*/
+
+
+
+
+#ifndef __CVCXCONNUTILWAITSCH_H
+#define __CVCXCONNUTILWAITSCH_H
+
+// INCLUDES
+#include <e32std.h>
+#include <e32base.h>
+#include <e32hashtab.h>
+
+
+class CVcxConnUtilWait;
+class CActiveSchedulerWait;
+
+// CLASS DECLARATION
+
+/**
+ * CVcxConnUtilWaitSch is used to manage CActiveSchedulerWait objects
+ * within videoconnutility.
+ * Basically, when client calls wait, a new CActiveSchedulerWait is created 
+ * and being put to list. Different types for waits are managed by different
+ * wait -wrapper object, which type is defined as a private class for this class.
+ * 
+ * Currently videoconnutility puts active objects to wait in following situations:
+ * 
+ * (1) When there is connection creation ongoing and other active objects try to 
+ * create connection: only the one active object that is creating connection is runnig, 
+ * other a-objects waits as long as connection is ready
+ * 
+ * (2) Master waiting for roaming status from slave instances: Master's roaming active object is 
+ * waiting for roaming response status change.
+ * 
+ * (3) Connection creation during roaming: All active objects requesting connection during roaming
+ * are put to wait for the roaming to finish, so that correct iap id can be returned.
+ * 
+ * (4) Disconnecting during roaming. Master's disconnecting a-object(s) is put to wait for
+ * roaming to finish
+ * 
+ * Waiting is released by the client by calling EndWait. CVcxConnUtilWaitSch basicallly 
+ * stops wait for every wait object, put those whose type is not the one provided 
+ * by the parameter of EndWait are being put back to wait. This solution is needed, to 
+ * prevent deadlocks: we might have different kind of waits at the same time, but not all
+ * are to be released at the same time, but because of the nature of the ActiveScheduler,
+ * all wait objects are needed to release once, before anyone can proceed.
+ * 
+ * 
+ */
+NONSHARABLE_CLASS( CVcxConnUtilWaitSch ) : public CBase
+    {
+    public: // Constructors and destructor
+
+        /**
+         * Destructor.
+         */
+        ~CVcxConnUtilWaitSch();
+    
+        /**
+         * Two-phased constructor.
+         */
+        static CVcxConnUtilWaitSch* NewL();
+    
+        /**
+         * Two-phased constructor.
+         */
+        static CVcxConnUtilWaitSch* NewLC();
+
+    private:
+
+        /**
+         * Constructor for performing 1st stage construction
+         */
+        CVcxConnUtilWaitSch();
+    
+        /**
+         * EPOC default constructor for performing 2nd stage construction
+         */
+        void ConstructL();
+    
+    public:
+  
+        /**
+         * Method creates a new CVcxConnUtilWait object in case
+         * one with provided type does not already exist, then
+         * creates a CActiveSchedulerWait object for the current
+         * active object and puts it to wait by calling 
+         * CActiveSchedulerWait::Start. After call returns (wait has 
+         * released) checks if CVcxConnUtilWait's iCanStop is ETrue.
+         * In case it is not, the object is being put back to wait. 
+         * 
+         * After wait object is really released, it is being deallocated. 
+         * 
+         * Method leaves with systemwide error code, in case object 
+         * creation or saving to array fails.
+         * 
+         * @param aWaitId wait type id for this wait
+         */
+        void WaitL( TUint32 aWaitId );
+        
+        
+        /**
+         * Method loops all CVcxConnUtilWait objects and sets their
+         * iCanStop to ETrue, in case aWaitId is same as CVcxConnUtilWait's
+         * iType. 
+         * All CActiveSchedulerWait's for each CVcxConnUtilWait is being 
+         * released by calling CActiveSchedulerWait::AsyncStop.
+         * 
+         * @param aWaitId wait type id for this wait
+         */
+        void EndWait( TUint32 aWaitId );
+        
+    
+    private:
+                         
+        /**
+         * Internal helper method for getting corresponding 
+         * CVcxConnUtilWait object based in the aID. 
+         * 
+         * In case aID -type object is not found from the 
+         * iWaits -array, it is being created and appended to array.
+         * 
+         * @param aID wait type id for this wait
+         */
+        CVcxConnUtilWait* GetWaitL( TUint32 aID );
+        
+        /**
+         * Internal helper method for PrepareWaitObjectL for 
+         * getting next not started Active scheduler wait 
+         * object for given CVcxConnUtilWait.
+         * 
+         * If there is no existing not started object or given
+         * CVcxConnUtilWait is NULL a new  CActiveSchedulerWait
+         * object is created and appended to the aWait object's
+         * waitarray.
+         * 
+         * 
+         * @param aWait wait wait object from where to search
+         */
+        CActiveSchedulerWait* GetActiveSWaitL( CVcxConnUtilWait* aWait );
+        
+    private:       
+        /**
+         * Array containing all CVcxConnUtilWait objects maintained
+         * by this object  
+         */
+        RPointerArray< CVcxConnUtilWait > iWaits;
+
+    };
+
+#endif // __CVCXCONNUTILWAITSCH_H