/*
* 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 definition file*
*/





#include "vcxconnutilwaitsch.h"


 /**
 * CVcxConnUtilWait is used to wrap CActiveScheduler objects to be used
 * as "wait-type" context within videoconnutility.
 * Each CVcxConnUtilWait object has a wait type -id for whose
 * object maintans an array of CActiveScheduler objects' wait state.
 */
NONSHARABLE_CLASS( CVcxConnUtilWait ) : public CBase
    {
    public: 
        
        /**
         * Destructor.
         */
        ~CVcxConnUtilWait()
            {
            iWaitArray.ResetAndDestroy();
            };
        
        /**
         * Default constructor
         */
        CVcxConnUtilWait( ) {};
        
        /**
         * Wait type id
         */
        TUint32 iType;
        
        /**
         * Flag to indicate wether CActiveScheduler maintained
         * by this object can really be released. In case flag is 
         * false, CActiveScheduler -objects need to be put to wait
         * again right after their release.  
         */
        TBool   iCanStop;
        
        /**
         * Array containing CActiveScheduler maintained
         * by this object  
         */
        RPointerArray < CActiveSchedulerWait > iWaitArray;
    };


// -----------------------------------------------------------------------------
// CVcxConnUtilWaitSch::CVcxConnUtilWaitSch()
// -----------------------------------------------------------------------------
//
CVcxConnUtilWaitSch::CVcxConnUtilWaitSch()
    {
    // No implementation required
    }

// -----------------------------------------------------------------------------
// CVcxConnUtilWaitSch::~CVcxConnUtilWaitSch()
// -----------------------------------------------------------------------------
//
CVcxConnUtilWaitSch::~CVcxConnUtilWaitSch()
    {
    iWaits.ResetAndDestroy();
    }

// -----------------------------------------------------------------------------
// CVcxConnUtilWaitSch::NewLC()
// -----------------------------------------------------------------------------
//
CVcxConnUtilWaitSch* CVcxConnUtilWaitSch::NewLC()
    {
    CVcxConnUtilWaitSch* self = new (ELeave)CVcxConnUtilWaitSch();
    CleanupStack::PushL(self);
    return self;
    }

// -----------------------------------------------------------------------------
// CVcxConnUtilWaitSch::NewL()
// -----------------------------------------------------------------------------
//
CVcxConnUtilWaitSch* CVcxConnUtilWaitSch::NewL()
    {
    CVcxConnUtilWaitSch* self = CVcxConnUtilWaitSch::NewLC();
    CleanupStack::Pop( self ); // self;
    return self;
    }

// -----------------------------------------------------------------------------
// CVcxConnUtilWaitSch::WaitL()
// -----------------------------------------------------------------------------
//
void CVcxConnUtilWaitSch::WaitL( TUint32 aWaitId )
    {
    CVcxConnUtilWait* wait = GetWaitL( aWaitId );
    CActiveSchedulerWait* activeWait = GetActiveSWaitL( wait ); 
        
    while( !wait->iCanStop )
        {
        activeWait->Start();        
        }
    
    TInt index = wait->iWaitArray.FindL( activeWait );
    if( index != KErrNotFound )
        {       
        wait->iWaitArray.Remove( index );
        }
    delete activeWait;
    
    if( !wait->iWaitArray.Count() )
        {
        index = iWaits.FindL( wait );
        if( index != KErrNotFound )
            {            
            iWaits.Remove( index );
            }
        delete wait;
        }
    }

// -----------------------------------------------------------------------------
// CVcxConnUtilWaitSch::EndWait()
// -----------------------------------------------------------------------------
//
void CVcxConnUtilWaitSch::EndWait( TUint32 aWaitId )
    {
    TInt waitCount( 0 );
    TInt asWaitCount( 0 );
    
    waitCount = iWaits.Count();
    
    for( TInt i( 0 ); i < waitCount; ++i )
        {
        iWaits[ i ]->iCanStop = ( aWaitId == iWaits[ i ]->iType );
        
        asWaitCount = iWaits[ i ]->iWaitArray.Count();
        
        for( TInt j( 0 ); j < asWaitCount; ++j )
            {
            if( iWaits[ i ]->iWaitArray[ j ]->IsStarted() )
                {
                iWaits[ i ]->iWaitArray[ j ]->AsyncStop();
                }
            }
        }
    }

// -----------------------------------------------------------------------------
// CVcxConnUtilWaitSch::GetWaitL()
// -----------------------------------------------------------------------------
//
CVcxConnUtilWait* CVcxConnUtilWaitSch::GetWaitL( TUint32 aID )
    {
    CVcxConnUtilWait* wait( 0 );
    TInt count( 0 );
    count = iWaits.Count();
    
    for( TInt i( 0 ); i < count; ++i )
        {
        if( iWaits[ i ]->iType == aID )
            {
            wait = iWaits[ i ];
            break;
            }
        }
    if( !wait )
        {
        wait = new (ELeave) CVcxConnUtilWait();
        CleanupStack::PushL( wait );
        wait->iType = aID;
        iWaits.AppendL( wait );
        CleanupStack::Pop( wait );
        }
    return wait;
    }

// -----------------------------------------------------------------------------
// CVcxConnUtilWaitSch::GetActiveSWaitL()
// -----------------------------------------------------------------------------
//
CActiveSchedulerWait* CVcxConnUtilWaitSch::GetActiveSWaitL( CVcxConnUtilWait* aWait )
    {  
    CActiveSchedulerWait* item( 0 );
    if( aWait )
        {
        TInt count( aWait->iWaitArray.Count() );
        for( TInt i( 0 ); i < count; i++ )
            {
            if( !( aWait->iWaitArray[i]->IsStarted() ) )
                {
                item = aWait->iWaitArray[i];
                break;
                }
            }
        }
    if( !item )
        {
        item = new ( ELeave) CActiveSchedulerWait;
        CleanupStack::PushL( item );
        aWait->iWaitArray.AppendL( item );
        CleanupStack::Pop( item );
        }
    return item;
    }
// End of file