/*

* Copyright (c) 2002-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:  Utility class for BIP

*

*/

#include <es_sock.h>

#include <etelqos.h>

#include "SatLog.h"

#include "CSatBIPUtils.h"

#include "CSatBIPGPRSDataChannel.h"

#include "csatbipconnectionobserver.h"

#include "MSatBIPDataChannel.h"

#include "MSatBIPChannelStatusObserver.h"

#include "MSatBIPDataAvailableObserver.h"

//lint -e766 Used inside TRAP macro, lint misfunction.

#include "EnginePanic.h"

#include "TSatChannelIDInfo.h"

#include "MSatUtils.h"

#include "CSatApnHandler.h"

#include "csatsactivewrapper.h"

#include "msatmultimodeapi.h"

const TInt KPDPContextPos( 7 );

const TInt KMaxAvailChannels( 7 );

const TInt8 KProposeQoSParametersPop( 2 );

// ======== MEMBER FUNCTIONS ========

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

// Two-phased constructor.

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

//

CSatBIPUtils* CSatBIPUtils::NewL( MSatUtils& aUtils )

    {

    LOG( SIMPLE, "SATENGINE: CSatBIPUtils::NewL calling" )

    CSatBIPUtils* self = new ( ELeave ) CSatBIPUtils( aUtils );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    LOG( SIMPLE, "SATENGINE: CSatBIPUtils::NewL exiting" )

    return self;

    }

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

// Destructor

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

//

CSatBIPUtils::~CSatBIPUtils()

    {

    LOG( SIMPLE, "SATENGINE: CSatBIPUtils::~CSatBIPUtils calling" )

    // Close all data channels

    if ( iDataChannels )

        {

        iDataChannels->ResetAndDestroy();

        }

    delete iDataChannels;

    if ( iChannelIds )

        {

        iChannelIds->ResetAndDestroy();

        }

    delete iChannelIds;

    delete iChannelId;

    LOG( SIMPLE, "SATENGINE: CSatBIPUtils::~CSatBIPUtils\

            Close connection and subconnection" )

    iSubConnection.Close();

    iConnection.Close();

    iSocketServer.Close();

    iPacketService.Close();

    delete iApnHandler;

    if ( iWrapper )

        {

        iWrapper->CancelWrapper();

        delete iWrapper;

        iWrapper = NULL;

        }

    if ( iConnObserver )

        {

        iConnObserver->Cancel();

        delete iConnObserver;

        iConnObserver = NULL;

        }

    iDataAvailableObserver = NULL;

    iChannelStatusObserver = NULL;

    LOG( SIMPLE, "SATENGINE: CSatBIPUtils::~CSatBIPUtils exiting" )

    }

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

// Handles event

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

//

void CSatBIPUtils::Event( TInt aEvent )

    {

    LOG( SIMPLE, "SATENGINE: CSatBIPUtils::Event calling" )

    // Check event

    if ( MSatUtils::ECommandCancelled == aEvent ||

         MSatUtils::ECancelledUsingEndKey == aEvent )

        {

        LOG( SIMPLE, "SATENGINE: CSatBIPUtils::Event check event" )

        if ( iDataChannels )

            {

            const TInt channelCount( iDataChannels->Count() );

            LOG2( SIMPLE, "SATENGINE: CSatBIPUtils::Event channelCount: %d",

                  channelCount )

            // Cancel all channels

            for ( TInt index = 0; index < channelCount; index++ )

                {

                MSatBIPDataChannel* channel = iDataChannels->At( index );

                __ASSERT_ALWAYS( channel,

                    PanicSatEngine( ESatEngineNullPointer ) );

                channel->CancelAll();

                }

            }

        }

    LOG( SIMPLE, "SATENGINE: CSatBIPUtils::Event exiting" )

    }

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

// Creates new data channel

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

//

MSatBIPDataChannel* CSatBIPUtils::CreateChannelL(

    const TSatBearerType aBearerType, TInt& aErrCode )

    {

    LOG( SIMPLE, "SATENGINE: CSatBIPUtils::CreateChannelL calling" )

    TInt errCode( MSatBIPUtils::ESatBIPNoChannelAvail );

    MSatBIPDataChannel* channel = NULL;

    // Get available channel ID

    TSatChannelIdInfo* channelId( AvailableChannelID() );

    // Check is the channel available

    if ( channelId )

        {

        // Create the right type of data channel

        if ( MSatBIPUtils::ESatGPRS == aBearerType )

            {

            LOG( NORMAL, 

            "SATENGINE: CSatBIPUtils::CreateChannelL ESatGPRS" )

            // New GPRS data channel

            channel = CSatBIPGPRSDataChannel::NewLC( *this, iSocketServer,

                *channelId, iConnection, iSubConnection );

            // Reserve channel ID

            channelId->ReserveChannel();

            // Add data channel to list

            iDataChannels->AppendL( channel );

            // Remove from CleanupStack

            CleanupStack::Pop( /* channel */ );

            // Return code

            errCode = MSatBIPUtils::ESatBIPSuccess;

#ifndef SAT_USE_DUMMY_TSY

            // Start connection observer

            if ( !iConnObserver )

                {

                LOG( NORMAL, " Starting connection observer" )

                iConnObserver = 

                    new ( ELeave ) CSatBIPConnectionObserver( *this );

                iConnObserver->StartObserver();

                }

#endif

            }

        else

            {

            // Others that GPRS are not yet supported

            LOG( NORMAL, 

                "SATENGINE: CSatBIPUtils::CreateChannelL Not supported" )

            errCode = MSatBIPUtils::ESatBIPNoChannelAvail;

            }

        }

    else

        {

        // Channel IDs not available

        LOG( NORMAL, 

            "SATENGINE: CSatBIPUtils::CreateChannelL Not available" )

        errCode = MSatBIPUtils::ESatBIPNoChannelAvail;

        }

    // Assign completion code

    aErrCode = errCode;

    LOG( SIMPLE, "SATENGINE: CSatBIPUtils::CreateChannelL exiting" )

    return channel;

    }

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

// Closes the data channel

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

//

TInt CSatBIPUtils::CloseChannel( const TInt aChannelId )

    {

    LOG( SIMPLE, "SATENGINE: CSatBIPUtils::CloseChannel calling" )

    TInt errCode( MSatBIPUtils::ESatBIPChannelIdNotValid );

    TInt index( 0 );

    TBool channelClosed( EFalse );

    // Loop the list of data channels and close the correct one.

    while ( index < iDataChannels->Count() && !channelClosed )

        {

        MSatBIPDataChannel* channel = iDataChannels->At( index );

        __ASSERT_ALWAYS( channel, PanicSatEngine( ESatEngineNullPointer ) );

        if ( channel->ChannelId() == aChannelId )

            {

            LOG( SIMPLE, "SATENGINE: CSatBIPUtils::CloseChannel \

            channel->ChannelId() == aChannelId" )

             // Makes next data channel creation possible

            iDataChannelActivated = EFalse;

            // Channel found, close it and return Success.

            channel->CloseChannel();

            // Delete data channel

            iDataChannels->Delete( index );

            delete channel;

            errCode = MSatBIPUtils::ESatBIPSuccess;

            channelClosed = ETrue;

            }

        // Goto next channel

        index++;

        }

    LOG2( SIMPLE, "SATENGINE: CSatBIPUtils::CloseChannel index: %d", index )

    // Free the space left in possible Delete call.

    iDataChannels->Compress();

    // Close connections if there're no active channels

    if ( !IsContextActive() )

        {

        LOG( SIMPLE, "SATENGINE: CSatBIPUtils::CloseChannel\

            Close connection and subconnection" )

        iSubConnection.Close();

        SetSubConnectionActivated( EFalse );

        iConnection.Close();

        SetConnectionActivated( EFalse );

        if ( iConnObserver )

            {

            iConnObserver->Cancel();

            delete iConnObserver;

            iConnObserver = NULL;

            }

        LOG( SIMPLE, "SATENGINE: CSatBIPUtils::CloseChannel\

            Close iPacketService" )

        iPacketService.Close();

        iPacketServiceActive = EFalse;

        }

    LOG( SIMPLE, "SATENGINE: CSatBIPUtils::CloseChannel exiting" )

    return errCode;

    }

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

// Closes all data channels

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

//

void CSatBIPUtils::CloseAllChannels()

    {

    LOG( SIMPLE, "SATENGINE: CSatBIPUtils::CloseAllChannels calling" )

    LOG2( SIMPLE, "SATENGINE: CSatBIPUtils::CloseAllChannels \

          channelcount: %d", iChannelIds->Count() )

    // Loop the list of data channels and close the correct one.

    for ( TInt i = 0; i < iChannelIds->Count(); i++ )

        {

        TSatChannelIdInfo* id = iChannelIds->At( i );

        // If channel is reserved -> Close it

        if ( id->IsReserved() )

            {

            LOG( SIMPLE, "SATENGINE: CSatBIPUtils::CloseAllChannels \

            id->IsReserved()" )

            CloseChannel( id->ChannelId() );

            }

        }

    // Close subsession to socket server

    LOG( SIMPLE, "SATENGINE: CSatBIPUtils::CloseAllChannels\

            Close connection and subconnection" )

    iSubConnection.Close();

    SetSubConnectionActivated( EFalse );

    iConnection.Close();

    SetConnectionActivated( EFalse );

    LOG( SIMPLE, "SATENGINE: CSatBIPUtils::CloseAllChannels exiting" )

    }

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

// Returns the correct data channel

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

//

MSatBIPDataChannel* CSatBIPUtils::DataChannel( const TInt aChannelId,

            TInt& aErrCode )

    {

    LOG( SIMPLE, "SATENGINE: CSatBIPUtils::DataChannel calling" )

    // If the channel cannot be found, returns channel not valid error code

    TInt errCode( MSatBIPUtils::ESatBIPChannelIdNotValid );

    MSatBIPDataChannel* channel = NULL;

    TBool found( EFalse );

    TInt index( 0 );

    // Loop the list of data channels and return the correct one.

    while ( index < iDataChannels->Count() && !found )

        {

        channel = iDataChannels->At( index );

        __ASSERT_ALWAYS( channel, PanicSatEngine( ESatEngineNullPointer ) );

        // Compare channel ID's

        if ( channel->ChannelId() == aChannelId )

            {

            LOG( SIMPLE, "SATENGINE: CSatBIPUtils::DataChannel \

            channel->ChannelId() == aChannelId" )

            // Channel found

            found = ETrue;

            if ( channel->IsContextActive() )

                {

                LOG( SIMPLE, "SATENGINE: CSatBIPUtils::DataChannel \

                IsContextActive" )

                // Channel found and it is active

                errCode = MSatBIPUtils::ESatBIPSuccess;

                }

            else

                {

                // Channel found but it is closed

                errCode = MSatBIPUtils::ESatBIPChannelClosed;

                }

            }

        index++;

        }

    LOG2( SIMPLE, "SATENGINE: CSatBIPUtils::DataChannel \

          index: %d", index )

    // Assign completion code to param

    aErrCode = errCode;

    LOG2( SIMPLE,

        "SATENGINE: CSatBIPUtils::DataChannel exiting with return code %d",

        errCode )

    return channel;

    }

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

// Generates TChannelStatus object

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

//

RSat::TChannelStatus CSatBIPUtils::GenerateChannelStatusL(

    const TInt aChannelId, TInt aStatus )

    {

    LOG( SIMPLE, "SATENGINE: CSatBIPUtils::GenerateChannelStatusL calling" )

    // ChannelStatus's first byte contains channel ID and pdp context status,

    // second byte contains information. values can be '00' or '05'

    RSat::TChannelStatus channelStatus;

    TInt err( MSatBIPUtils::ESatBIPNoChannelAvail );

    // Used to check the PDP context state

    MSatBIPDataChannel* dataChannel = DataChannel( aChannelId, err );

    // If channel is not active, status is still needed

    if ( ESatBIPSuccess == err || ESatBIPChannelClosed == err )

        {

        // Generate the first byte

        TUint8 channelId( 0 );   // last 3 bits.

        TUint8 pdpContext( 0 );  // first bit

        TUint8 firstByte( 0 );    // First byte

        // Channel ID. Bits 6 to 8.

        channelId = dataChannel->ChannelStatusChannelId();

        // If PDP Context is active, first bit is 1

        if ( dataChannel->IsContextActive() )

            {

            LOG( SIMPLE, "SATENGINE: CSatBIPUtils::GenerateChannelStatusL \

            dataChannel IsContextActive" )

            pdpContext = 1 << KPDPContextPos;

            }

        // We don't need data channel anymore

        dataChannel = NULL;

        // All the information for the first byte is gathered

        firstByte = static_cast<TUint8>( pdpContext ^ channelId );

        channelStatus.Append( firstByte );

        // Second byte should go straigth

        channelStatus.Append( aStatus );

        // LOG values

        LOG2( NORMAL,

            "SATENGINE: CSatBIPUtils::GenerateChannelStatusL First byte: %b",

            firstByte )

        LOG2( NORMAL,

            "SATENGINE: CSatBIPUtils::GenerateChannelStatusL Second byte: %b",

            aStatus )

        }

    else

        {

        LOG2( NORMAL, "SATENGINE: CSatBIPUtils::GenerateChannelStatusL \

            Data channel not found: %i", err )

        User::LeaveIfError( KErrNotFound );

        }

    LOG( SIMPLE, "SATENGINE: CSatBIPUtils::GenerateChannelStatusL exiting" )

    return channelStatus;

    }

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

// Returns the interface reference to APN handler

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

//

MSatApnHandler& CSatBIPUtils::ApnHandler()

    {

    LOG( SIMPLE, "SATENGINE: CSatBIPUtils::ApnHandler calling" )

    // Assert, Apn handler cannot be NULL

    __ASSERT_ALWAYS( iApnHandler, PanicSatEngine( ESatEngineNullPointer ) );

    LOG( SIMPLE, "SATENGINE: CSatBIPUtils::ApnHandler exiting" )

    return *iApnHandler;

    }

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

// Returns the state of the PDP Context

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

//

TBool CSatBIPUtils::IsContextActive()

    {

    LOG( SIMPLE, "SATENGINE: CSatBIPUtils::IsContextActive calling" )

    TBool retVal( EFalse );

    TInt index( 0 );

    // Loop the list of data channels and end if active channel is found

    while ( index < iDataChannels->Count() && !retVal )

        {

        MSatBIPDataChannel* channel = iDataChannels->At( index );

        __ASSERT_ALWAYS( channel, PanicSatEngine( ESatEngineNullPointer ) );

        retVal = channel->IsContextActive();

        // Goto next channel

        index++;

        }

    LOG2( SIMPLE, "SATENGINE: CSatBIPUtils::IsContextActive \

          index: %d", index )

    LOG( SIMPLE, "SATENGINE: CSatBIPUtils::IsContextActive exiting" )

    return retVal;

    }

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

// Returns the array of data channels

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

//

CArrayPtrFlat<MSatBIPDataChannel>* CSatBIPUtils::DataChannels()

    {

    LOG( SIMPLE, "SATENGINE: CSatBIPUtils::DataChannels calling - exiting" )

    return iDataChannels;

    }

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

// Request to notify when data is available

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

//

void CSatBIPUtils::NotifyDataAvailable(

    MSatBIPDataAvailableObserver* aObserver )

    {

    LOG( SIMPLE,

        "SATENGINE: CSatBIPUtils::NotifyDataAvailable calling - exiting" )

    iDataAvailableObserver = aObserver;

    }

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

// Request to notify when an error occurs in data channel

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

//

void CSatBIPUtils::NotifyChannelStatus(

    MSatBIPChannelStatusObserver* aObserver )

    {

    LOG( SIMPLE,

        "SATENGINE: CSatBIPUtils::NotifyChannelStatus calling - exiting" )

    iChannelStatusObserver = aObserver;

    }

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

// Cancels the DataAvailable request

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

//

void CSatBIPUtils::CancelDataAvailable()

    {

    LOG( SIMPLE,

        "SATENGINE: CSatBIPUtils::CancelDataAvailable calling - exiting" )

    iDataAvailableObserver = NULL;

    }

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

// Cancels the ChannelStatus request

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

//

void CSatBIPUtils::CancelChannelStatus()

    {

    LOG( SIMPLE,

        "SATENGINE: CSatBIPUtils::CancelChannelStatus calling - exiting" )

    iChannelStatusObserver = NULL;

    }

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

// DataAvailable event. Notifies observer.

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

//

void CSatBIPUtils::DataAvailable( const TInt aChannelId, const TInt aLength )