/*

* 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