/*

* Copyright (c) 2007 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:  Definitions needed for common stream functionality

*

*/

/*

 * TODO: When local media is of type RComm, listening on it is started with

 * RComm::NotifyDataAvailable() call. Check that USB ACM port and Irda RCOMM

 * (and any other new media in the future) behaves correctly so that when

 * RComm::ReadOneOrMore() is issued, the read is issued immediately without

 * checking for new data. If waiting for new data happens in this

 * NotifyDataAvailable/ReadOneOrMore combination, raise a defect to Symbian.

 */

#include "DunStream.h"

#include "DunDebug.h"

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

// Destructor.

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

//

CDunStream::~CDunStream()

    {

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

    ResetData();

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

    }

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

// Resets data to initial values

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

//

void CDunStream::ResetData()

    {

    // APIs affecting this:

    // AddConnMonCallback()

    iCallbacksR.Close();

    iCallbacksW.Close();

    // AddSkippedError()

    iOkErrorsR.Close();

    iOkErrorsW.Close();

    // Internal

    Initialize();

    }

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

// Adds error code to consider as "no error" to either endpoint

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

//

TInt CDunStream::AddSkippedError( TInt aError,

                                  TDunOperationType aOperationType )

    {

    FTRACE(FPrint( _L("CDunStream::AddSkippedError()" ) ));

    RArray<TInt>* okErrors = NULL;

    if ( aOperationType == EDunOperationTypeRead )

        {

        okErrors = &iOkErrorsR;

        }

    else if ( aOperationType == EDunOperationTypeWrite )

        {

        okErrors = &iOkErrorsW;

        }

    else

        {

        FTRACE(FPrint( _L("CDunStream::AddSkippedError() (ERROR) complete" ) ));

        return KErrGeneral;

        }

    if ( aError >= 0 )  // errors can't be >= 0

        {

        FTRACE(FPrint( _L("CDunStream::AddSkippedError() (ERROR) complete" ) ));

        return KErrGeneral;

        }

    TInt retTemp = okErrors->Find( aError );

    if ( retTemp != KErrNotFound )

        {

        FTRACE(FPrint( _L("CDunStream::AddSkippedError() (already exists) complete" ) ));

        return KErrAlreadyExists;

        }

    retTemp = okErrors->Append( aError );

    if ( retTemp != KErrNone )

        {

        FTRACE(FPrint( _L("CDunStream::AddSkippedError() (append failed!) complete" ) ));

        return retTemp;

        }

    FTRACE(FPrint( _L("CDunStream::AddSkippedError() complete" ) ));

    return KErrNone;

    }

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

// Adds callback for line status change controlling

// The callback will be called when serious read error is detected

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

//

TInt CDunStream::AddConnMonCallback( MDunConnMon* aCallback,

                                     TDunOperationType aOperationType )

    {

    FTRACE(FPrint( _L("CDunStream::AddConnMonCallback()" ) ));

    RPointerArray<MDunConnMon>* callbacks = NULL;

    if ( aOperationType == EDunOperationTypeRead )

        {

        callbacks = &iCallbacksR;

        }

    else if ( aOperationType == EDunOperationTypeWrite )

        {

        callbacks = &iCallbacksW;

        }

    else

        {

        FTRACE(FPrint( _L("CDunStream::AddConnMonCallback() (ERROR) complete" ) ));

        return KErrGeneral;

        }

    if ( !aCallback )

        {

        FTRACE(FPrint( _L("CDunStream::AddConnMonCallback() (aCallback) not initialized!" ) ));

        return KErrGeneral;

        }

    TInt retTemp = callbacks->Find( aCallback );

    if ( retTemp != KErrNotFound )

        {

        FTRACE(FPrint( _L("CDunStream::AddCallback() (already exists) complete" ) ));

        return KErrAlreadyExists;

        }

    retTemp = callbacks->Append( aCallback );

    if ( retTemp != KErrNone )

        {

        FTRACE(FPrint( _L("CDunStream::AddCallback() (append failed!) complete" ) ));

        return retTemp;

        }

    FTRACE(FPrint( _L("CDunStream::AddCallback() complete" ) ));

    return KErrNone;

    }

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

// Sets buffering for this stream

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

//

TInt CDunStream::SetBuffering( TPtr8* aBufferPtr )

    {

    FTRACE(FPrint( _L("CDunStream::SetBuffering()" ) ));

    if ( !aBufferPtr )

        {

        FTRACE(FPrint( _L("CDunStream::SetBuffering() (aBufferPtr) not initialized!" ) ));

        return KErrGeneral;

        }

    if ( iBufferPtr )

        {

        FTRACE(FPrint( _L("CDunStream::SetBuffering() (already exists) complete" ) ));

        return KErrAlreadyExists;

        }

    iBufferPtr = aBufferPtr;

    FTRACE(FPrint( _L("CDunStream::SetBuffering() complete" ) ));

    return KErrNone;

    }

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

// Sets media to use for this endpoint

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

//

TInt CDunStream::SetMedia( RComm* aComm, TDunMediaContext aMediaContext )

    {

    FTRACE(FPrint( _L("CDunStream::SetMedia() (RComm)" ) ));

    if ( !aComm )

        {

        FTRACE(FPrint( _L("CDunStream::SetMedia() (RComm) (aComm not initialized!) complete" ) ));

        return KErrGeneral;

        }

    if ( aMediaContext == EDunMediaContextNetwork )

        {

        iNetwork = aComm;

        }

    else if ( aMediaContext == EDunMediaContextLocal )

        {

        iComm = aComm;

        }

    else

        {

        FTRACE(FPrint( _L("CDunStream::SetMedia() (RComm) (ERROR) complete" )));

        return KErrGeneral;

        }

    FTRACE(FPrint( _L("CDunStream::SetMedia() (RComm) complete" ) ));

    return KErrNone;

    }

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

// Sets media to use for this endpoint

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

//

TInt CDunStream::SetMedia( RSocket* aSocket,

                           TDunMediaContext aMediaContext )

    {

    FTRACE(FPrint( _L("CDunStream::SetMedia() (RSocket)" ) ));

    if ( !aSocket )

        {

        FTRACE(FPrint( _L("CDunStream::SetMedia() (RSocket) (aSocket not initialized!) complete" ) ));

        return KErrGeneral;

        }

    if ( aMediaContext == EDunMediaContextLocal )

        {

        iSocket = aSocket;

        }

    else

        {

        FTRACE(FPrint( _L("CDunStream::SetMedia() (RSocket) (not supported) complete" ) ));

        return KErrNotSupported;

        }

    FTRACE(FPrint( _L("CDunStream::SetMedia() (RSocket) complete" ) ));

    return KErrNone;

    }

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

// Gets media context

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

//

TDunMediaContext CDunStream::GetMediaContext( TDunStreamType aStreamType )

    {

    FTRACE(FPrint( _L("CDunStream::GetMediaContext()" ) ));

    if ( aStreamType == EDunStreamTypeUpstream )

        {

        if ( iOperationType == EDunOperationTypeRead )

            {

            return EDunMediaContextLocal;

            }

        else if ( iOperationType == EDunOperationTypeWrite )

            {

            return EDunMediaContextNetwork;

            }

        else

            {

            return EDunMediaContextUndefined;

            }

        }

    else if ( aStreamType == EDunStreamTypeDownstream )

        {

        if ( iOperationType == EDunOperationTypeRead )

            {

            return EDunMediaContextNetwork;

            }

        else if ( iOperationType == EDunOperationTypeWrite )

            {

            return EDunMediaContextLocal;

            }

        else

            {

            return EDunMediaContextUndefined;

            }

        }

    FTRACE(FPrint( _L("CDunStream::GetMediaContext() complete" ) ));

    return EDunMediaContextUndefined;

    }

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

// Check whether an error code is severe error or not

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

//

TInt CDunStream::ProcessErrorCondition( TInt aError, TBool& aIsError )

    {

    FTRACE(FPrint( _L("CDunStream::ProcessErrorCondition() (Dir=%d)" ), iDirection));

    aIsError = EFalse;

    if ( aError != KErrNone )

        {

        aIsError = ETrue;

        RArray<TInt>* okErrors = NULL;

        if ( iOperationType == EDunOperationTypeRead )

            {

            okErrors = &iOkErrorsR;

            }

        else // iOperationType == EDunOperationTypeWrite

            {

            okErrors = &iOkErrorsW;

            }

        TInt retTemp = okErrors->Find( aError );

        if ( retTemp == KErrNotFound )

            {

            FTRACE(FPrint( _L("CDunStream::ProcessErrorCondition() (Dir=%d) (%d=ETrue) complete" ), iDirection, aError));

            return ETrue;

            }

        }

    FTRACE(FPrint( _L("CDunStream::ProcessErrorCondition() (Dir=%d) (%d=EFalse) complete" ), iDirection, aError));

    return EFalse;

    }

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

// CDunStream::CDunStream

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

//

CDunStream::CDunStream() : CActive( EPriorityHigh )

    {

    Initialize();

    CActiveScheduler::Add( this );

    }

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

// Initializes this class

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

//

void CDunStream::Initialize()

    {

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

    iBufferPtr = NULL;

    iReadLengthSocket = 0;

    iOperationType = EDunOperationTypeUndefined;

    iTransferState = EDunStateIdle;

    iDirection = EDunDirectionUndefined;

    iNetwork = NULL;

    iSocket = NULL;

    iComm = NULL;

    }