/*

* Copyright (c) 2006-2008 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:  RComm channel management related functionality (waiter)

*

*/

#include "DunSignalWaiter.h"

#include "DunDataWaiter.h"

#include "DunUpstream.h"

#include "DunDownstream.h"

#include "DunSignalCopy.h"

#include "DunChanMan.h"

#include "DunUtils.h"

#include "DunDebug.h"

#include "DunPlugin.h"

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

// Two-phased constructor.

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

//

CDunChanMan* CDunChanMan::NewL( CDunTransporter& aParent,

                                MDunTransporterUtility* aUtility,

                                MDunTransporterUtilityAux* aUtilityAux,

                                MDunPluginManager* aPluginManager )

    {

    CDunChanMan* self = new (ELeave) CDunChanMan( aParent,

                                                  aUtility,

                                                  aUtilityAux,

                                                  aPluginManager );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor.

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

//

CDunChanMan::~CDunChanMan()

    {

    FTRACE(FPrint( _L("CDunChanMan::~CDunChanMan()") ));

    ResetData();

    FTRACE(FPrint( _L("CDunChanMan::~CDunChanMan() complete") ));

    }

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

// Resets data to initial values

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

//

void CDunChanMan::ResetData()

    {

    FTRACE(FPrint( _L("CDunChanMan::ResetData()") ));

    // APIs affecting this:

    // AddConnWaiterL()

    // IssueConnWaiterRequest()

    TInt i;

    TInt count = iWaiterData.Count();

    for ( i=0; i<count; i++ )

        {

        DeleteWaiters( i );

        }

    iWaiterData.Close();

    FTRACE(FPrint( _L("CDunChanMan::ResetData() complete") ));

    }

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

// Number of waiters

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

//

TInt CDunChanMan::NumberOfWaiters()

    {

    FTRACE(FPrint( _L("CDunChanMan::NumberOfWaiters()" )));

    TInt waiters = iWaiterData.Count();

    FTRACE(FPrint( _L("CDunChanMan::NumberOfWaiters() complete" )));

    return waiters;

    }

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

// Gets number of waiters by owner UID

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

//

TInt CDunChanMan::GetNumberOfWaitersByUid( TUid aOwnerUid )

    {

    FTRACE(FPrint( _L("CDunChanMan::GetNumberOfWaitersByUid()" )));

    TInt i;

    TInt waiters = 0;

    TInt count = iWaiterData.Count();

    for ( i=0; i<count; i++ )

        {

        TDunWaiterData& waiterData = iWaiterData[i];

        if ( waiterData.iOwnerUid == aOwnerUid )

            {

            waiters++;

            }

        }

    FTRACE(FPrint( _L("CDunChanMan::GetNumberOfWaitersByUid() complete" )));

    return waiters;

    }

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

// Adds new connection waiter to connection waiter array

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

//

void CDunChanMan::AddConnWaiterL( RComm* aComm,

                                  TUid aOwnerUid,

                                  const TDesC8& aName,

                                  TBool aEnqueuedFail,

                                  MDunBufferCorrection* aCorrection )

    {

    FTRACE(FPrint( _L("CDunChanMan::AddConnWaiterL()" )));

    if ( !aComm )

        {

        FTRACE(FPrint( _L("CDunChanMan::AddConnWaiterL() (aComm not initialized!) complete" )));

        User::Leave( KErrGeneral );

        }

    CDunSignalWaiter* signalWaiter = CDunSignalWaiter::NewL( this );

    CleanupStack::PushL( signalWaiter );

    TInt retTemp = signalWaiter->SetMedia( aComm );

    if ( retTemp != KErrNone )

        {

        FTRACE(FPrint( _L("CDunChanMan::AddConnWaiterL() (ERROR) complete" )));

        User::Leave( retTemp );

        }

    CDunDataWaiter* dataWaiter = CDunDataWaiter::NewL( this );

    CleanupStack::PushL( dataWaiter );

    retTemp = dataWaiter->SetMedia( aComm );

    if ( retTemp != KErrNone )

        {

        FTRACE(FPrint( _L("CDunChanMan::AddConnWaiterL() (ERROR) complete" )));

        User::Leave( retTemp );

        }

    TDunWaiterData waiterData;

    waiterData.iComm = aComm;

    waiterData.iChannelName = HBufC8::NewMaxL( aName.Length() );

    TPtr8 chanNamePtr = waiterData.iChannelName->Des();

    chanNamePtr.Copy( aName );

    waiterData.iSignalWaiter = signalWaiter;

    waiterData.iDataWaiter = dataWaiter;

    waiterData.iCorrection = aCorrection;

    waiterData.iEnqueuedFail = aEnqueuedFail;

    waiterData.iOwnerUid = aOwnerUid;

    iWaiterData.AppendL( waiterData );

    CleanupStack::Pop( dataWaiter );

    CleanupStack::Pop( signalWaiter );

    FTRACE(FPrint( _L("CDunChanMan::AddConnWaiterL() complete" )));

    }

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

// Removes existing waiter from connection waiter array

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

//

TInt CDunChanMan::RemoveConnWaiter( RComm* aComm )

    {

    FTRACE(FPrint( _L("CDunChanMan::RemoveConnWaiter()" )));

    TInt i;

    for ( i=iWaiterData.Count()-1; i>=0; i-- )

        {

        TDunWaiterData& waiterData = iWaiterData[i];

        if ( waiterData.iComm == aComm )

            {

            DeleteWaiters( i );

            iWaiterData.Remove( i );

            FTRACE(FPrint( _L("CDunChanMan::RemoveConnWaiter() complete" )));

            return KErrNone;

            }

        }

    FTRACE(FPrint( _L("CDunChanMan::RemoveConnWaiter() (not found) complete" )));

    return KErrNotFound;

    }

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

// Makes CDunConnWaiter ready to detect new data

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

//

TInt CDunChanMan::IssueConnWaiterRequest( RComm* aComm )

    {

    FTRACE(FPrint( _L("CDunChanMan::IssueConnWaiterRequest()" )));

    TInt i;

    TInt count = iWaiterData.Count();

    for ( i=0; i<count; i++ )

        {

        TDunWaiterData& waiterData = iWaiterData[i];

        if ( waiterData.iComm == aComm )

            {

            waiterData.iSignalWaiter->IssueRequest();

            waiterData.iDataWaiter->IssueRequest();

            FTRACE(FPrint( _L("CDunChanMan::IssueConnWaiterRequest() complete" )));

            return KErrNone;

            }

        }

    FTRACE(FPrint( _L("CDunChanMan::IssueConnWaiterRequest() (not found) complete" )));

    return KErrNotFound;

    }

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

// Stops CDunConnWaiter to detect new data

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

//

TInt CDunChanMan::StopConnWaiter( RComm* aComm )

    {

    FTRACE(FPrint( _L("CDunChanMan::StopConnWaiter()" )));

    TInt i;

    TInt count = iWaiterData.Count();

    for ( i=0; i<count; i++ )

        {

        TDunWaiterData& waiterData = iWaiterData[i];

        if ( waiterData.iComm == aComm )

            {

            waiterData.iSignalWaiter->Stop();

            waiterData.iDataWaiter->Stop();

            FTRACE(FPrint( _L("CDunChanMan::StopConnWaiter() complete" )));

            return KErrNone;

            }

        }

    FTRACE(FPrint( _L("CDunChanMan::StopConnWaiter() (not found) complete" )));

    return KErrNotFound;

    }

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

// Saves waiter's connection monitor callback data

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

//

TInt CDunChanMan::SaveWaiterConnMonCallbackL( RComm* aComm,

                                              MDunConnMon* aCallback,

                                              TDunDirection aDirection )

    {

    FTRACE(FPrint( _L("CDunChanMan::SaveWaiterConnMonCallbackL()" )));

    TInt i;

    TInt count = iWaiterData.Count();

    for ( i=0; i<count; i++ )

        {

        TDunWaiterData& waiterData = iWaiterData[i];

        if ( waiterData.iComm != aComm )

            {

            continue;

            }

        TDunConnMonCallback connMon;

        connMon.iCallback = aCallback;

        connMon.iDirection = aDirection;

        if ( aDirection==EDunReaderUpstream ||

             aDirection==EDunWriterDownstream )

            {

            // Local media -> add to object

            // Add signal waiter's callback (for RunL error monitoring)

            if ( !waiterData.iSignalWaiter )

                {

                FTRACE(FPrint( _L("CDunTransUtils::SaveWaiterConnMonCallbackL() (ERROR) complete" )));

                return KErrGeneral;

                }

            waiterData.iSignalWaiter->AddCallback( aCallback );

            // Add data waiter's callback (for RunL error monitoring)

            if ( !waiterData.iDataWaiter )

                {

                FTRACE(FPrint( _L("CDunTransUtils::SaveWaiterConnMonCallbackL() (ERROR) complete" )));

                return KErrGeneral;

                }

            waiterData.iDataWaiter->AddCallback( aCallback );

            // Now just store information for R/W case

            waiterData.iConnMons.AppendL( connMon );

            FTRACE(FPrint( _L("CDunChanMan::SaveWaiterConnMonCallbackL() complete" )));

            return KErrNone;

            }

        else if ( aDirection==EDunWriterUpstream ||

                  aDirection==EDunReaderDownstream )

            {

            // Network -> just store information for R/W case

            waiterData.iConnMons.AppendL( connMon );

            FTRACE(FPrint( _L("CDunChanMan::SaveWaiterConnMonCallbackL() complete" )));

            return KErrNone;

            }

        else

            {

            FTRACE(FPrint( _L("CDunTransUtils::SaveWaiterConnMonCallbackL() (ERROR) complete" )));

            return KErrGeneral;

            }

        }

    FTRACE(FPrint( _L("CDunChanMan::SaveWaiterConnMonCallbackL() (not found) complete" )));

    return KErrNotFound;

    }

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

// Saves waiter's skipped error data

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

//

TInt CDunChanMan::SaveWaiterSkippedErrorL( TInt aError,

                                           RComm* aComm,

                                           TDunDirection aDirection )

    {

    FTRACE(FPrint( _L("CDunChanMan::SaveWaiterSkippedErrorL()" )));

    TInt i;

    TInt count = iWaiterData.Count();

    for ( i=0; i<count; i++ )

        {

        TDunWaiterData& waiterData = iWaiterData[i];

        if ( waiterData.iComm == aComm )

            {

            TDunSkippedError skippedError;

            skippedError.iError = aError;

            skippedError.iDirection = aDirection;

            waiterData.iOkErrors.AppendL( skippedError );

            FTRACE(FPrint( _L("CDunChanMan::SaveWaiterSkippedErrorL() complete" )));

            return KErrNone;

            }

        }

    FTRACE(FPrint( _L("CDunChanMan::SaveWaiterSkippedErrorL() (not found) complete" )));

    return KErrNotFound;

    }

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

// CDunChanMan::CDunChanMan

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

//

CDunChanMan::CDunChanMan( CDunTransporter& aParent,

                          MDunTransporterUtility* aUtility,

                          MDunTransporterUtilityAux* aUtilityAux,

                          MDunPluginManager* aPluginManager ) :

    iParent( aParent ),

    iUtility( aUtility ),

    iUtilityAux( aUtilityAux ),

    iPluginManager( aPluginManager )

    {

    Initialize();

    }

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

// CDunChanMan::ConstructL

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

//

void CDunChanMan::ConstructL()

    {

    FTRACE(FPrint( _L("CDunChanMan::ConstructL()" ) ));

    if ( !iUtility || !iUtilityAux || !iPluginManager )

        {

        User::Leave( KErrGeneral );

        }

    FTRACE(FPrint( _L("CDunChanMan::ConstructL() complete" ) ));

    }

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

// Initializes this class

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

//

void CDunChanMan::Initialize()

    {

    FTRACE(FPrint( _L("CDunChanMan::Initialize()" ) ));

    // Don't initialize iParent here (it is set through NewL)

    // Don't initialize iUtility here (it is set through NewL)

    // Don't initialize iUtilityAux here (it is set through NewL)

    // Don't initialize iPluginManager here (it is set through NewL)

    FTRACE(FPrint( _L("CDunChanMan::Initialize() complete" ) ));

    }

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

// From class MDunChannelAllocator.

// Notifies when new channel is wanted

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

//

TInt CDunChanMan::NotifyNewChannelRequest( RComm* aComm )

    {

    FTRACE(FPrint( _L("CDunChanMan::NotifyNewChannelRequest()" )));

    if ( !aComm->SubSessionHandle() )

        {

        FTRACE(FPrint( _L("CDunChanMan::NotifyNewChannelRequest() (RComm) (bad handle) complete" ) ));

        return KErrBadHandle;

        }

    // Get plugin UID for connection ID

    TInt i;

    TUid foundUid = TUid::Null();

    TInt count = iWaiterData.Count();

    for ( i=0; i<count; i++ )

        {

        if ( iWaiterData[i].iComm == aComm )

            {

            foundUid = iWaiterData[i].iOwnerUid;

            break;

            }

        }

    if ( i >= count )

        {

        FTRACE(FPrint( _L("CDunChanMan::NotifyNewChannelRequest() (RComm) (not found) complete" )));

        return KErrNotFound;

        }

    TDunWaiterData& waiterData = iWaiterData[i];

    // Try to stop if either one of the waiters are still runnig

    waiterData.iSignalWaiter->Stop();

    waiterData.iDataWaiter->Stop();

    // enqueued will be omitted (not needed to set to RComm)

    TInt firstFree = iUtility->InitializeFirstFreeChannel( aComm );

    if ( firstFree < 0 )

        {

        FTRACE(FPrint( _L("CDunChanMan::NotifyNewChannelRequest() (RComm) (firstfree failed!) complete" ) ));

        return firstFree;

        }

    if ( firstFree >= iParent.iChannelData.Count() )

        {

        FTRACE(FPrint( _L("CDunChanMan::NotifyNewChannelRequest() (RComm) (firstfree failed!) complete" )));

        return KErrGeneral;

        }

    TInt bufferLength = KErrNotFound;

    MDunBufferCorrection* correction = waiterData.iCorrection;

    TRAPD( retTrap,

        iUtility->DoAllocateChannelL(aComm, bufferLength, firstFree, correction) );

    if ( retTrap != KErrNone )

        {

        FTRACE(FPrint( _L("CDunChanMan::NotifyNewChannelRequest() trapped!" ) ));

        iParent.UnInitializeOnDemand();  // remove unused initialized channel

        if ( retTrap == KErrTooBig )

            {

            if ( waiterData.iEnqueuedFail )

                {

                // Inform plugin enqueue request

                iPluginManager->NotifyPluginEnqueueRequest( foundUid );

                }

            FTRACE(FPrint( _L("CDunTransporter::AllocateChannel() (RSocket) complete" )));

            return KErrTooBig;

            }

        iPluginManager->NotifyPluginCloseRequest( foundUid, EFalse );

        FTRACE(FPrint( _L("CDunChanMan::NotifyNewChannelRequest() (ERROR) complete" )));

        return retTrap;

        }

    TInt retTemp = CDunUtils::SetRCommBufferLength( *aComm, bufferLength );

    if ( retTemp != KErrNone )

        {

        iParent.UnInitializeOnDemand();  // remove unused initialized channel

        iPluginManager->NotifyPluginCloseRequest( foundUid, EFalse );

        FTRACE(FPrint( _L("CDunChanMan::NotifyNewChannelRequest() (ERROR) complete" )));

        }

    // Next find aComm from iWaiterData and copy its contents to channel data

    retTemp = FillNewWaiterChannelData( aComm, firstFree );

    if ( retTemp != KErrNone )

        {

        iParent.UnInitializeOnDemand();  // remove unused initialized channel

        iPluginManager->NotifyPluginCloseRequest( foundUid, EFalse );

        FTRACE(FPrint( _L("CDunChanMan::NotifyNewChannelRequest() (RComm) (not found) complete" )));

        }

    FTRACE(FPrint( _L("CDunChanMan::NotifyNewChannelRequest() (RComm) complete" )));

    return KErrNone;

    }

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

// Fills data for channel created by waiter

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

//

TInt CDunChanMan::FillNewWaiterChannelData( RComm* aComm,

                                            TInt aFirstFree )

    {

    FTRACE(FPrint( _L("CDunChanMan::FillNewWaiterChannelData()" )));

    TInt i;

    TInt count = iWaiterData.Count();

    for ( i=0; i<count; i++ )

        {

        if ( iWaiterData[i].iComm == aComm )

            {

            break;

            }

        }

    if ( i >= count ||

         aFirstFree < 0 ||

         aFirstFree >= iParent.iChannelData.Count() )

        {

        FTRACE(FPrint( _L("CDunChanMan::FillNewWaiterChannelData() (not found) complete" )));

        return KErrNotFound;

        }

    TUid thisUid = iWaiterData[i].iOwnerUid; // pick up before remove

    TDunChannelData& channelData = iParent.iChannelData[aFirstFree];

    TDunWaiterData& waiterData = iWaiterData[i];

    channelData.iComm = waiterData.iComm;

    channelData.iChannelName = waiterData.iChannelName;

    channelData.iUpstreamRW->SetMedia( aComm, EDunMediaContextLocal );

    channelData.iDownstreamRW->SetMedia( aComm, EDunMediaContextLocal );

    channelData.iOwnerUid = thisUid;

    // Channel now occupied

    channelData.iChannelInUse = ETrue;

    // Restore data from waiter to transfer objects

    RestoreWaiterData( i, aFirstFree );

    // Now delete waiters before request issuing

    DeleteWaiters( i, ETrue );

    iWaiterData.Remove( i );

    // Issue transfer requests

    iUtility->DoIssueTransferRequests( aFirstFree );

    // Clear the queue, just to be sure

    iPluginManager->NotifyPluginDequeueRequest( thisUid );

    FTRACE(FPrint( _L("CDunChanMan::FillNewWaiterChannelData() complete" )));

    return KErrNone;

    }

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

// Restores saved waiter data to connection data

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

//

TInt CDunChanMan::RestoreWaiterData( TInt aWaiterIndex,

                                     TInt aChannelIndex )

    {

    FTRACE(FPrint( _L("CDunChanMan::RestoreWaiterData()" )));

    if ( aWaiterIndex < 0 ||

         aWaiterIndex >= iWaiterData.Count() ||

         aChannelIndex < 0 ||

         aChannelIndex >= iParent.iChannelData.Count() )

        {

        FTRACE(FPrint( _L("CDunChanMan::RestoreWaiterData() (not found) complete" )));

        return KErrNotFound;

        }

    TInt i;

    TInt count = iWaiterData[aWaiterIndex].iConnMons.Count();

    for ( i=0; i<count; i++ )

        {

        TDunConnMonCallback& connMon = iWaiterData[aWaiterIndex].iConnMons[i];

        // Add connection monitor callbacks (ignore errors)

        // Errors are ignored because in this phase they cannot be reported to

        // plugins. Instead add error checking to

        // CDunTransporter::AddConnMonCallbackL() if needed

        iUtility->DoAddConnMonCallback( aChannelIndex,

                                        connMon.iCallback,

                                        connMon.iDirection,

                                        NULL );

        }