/*

* Copyright (c) 2005 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: 

*

*/

// USER

#include "musengmceoutsession.h"

#include "mussettings.h"

#include "musengmceutils.h"

#include "musenguriparser.h"

#include "musenglogger.h"

#include "mussipprofilehandler.h"

// SYSTEM

#include <mcestreambundle.h>

#include <mcemediastream.h>

#include <mceoutsession.h>

#include <mcevideostream.h>

#include <mcemediasource.h>

#include <mcefilesource.h>

#include <mcemediasink.h>

#include <mcertpsink.h>

#include <mcespeakersink.h>

#include <mcedisplaysink.h>

#include <mcevideocodec.h>

#include <mceaudiocodec.h>

#include <sipprofile.h>

#include <sipextensionheader.h>

#include <sipaddress.h>

#include <uri8.h>

const TInt KMusEngSipReasonCodeRecipientNotFound  = 404;

const TInt KMusEngSipReasonCodeRequestTimeout = 408;

const TInt KMusEngSipReasonCodeUnsupportedMediaType = 415;

const TInt KMusEngSipReasonCodeUnsupportedUriScheme = 416;

const TInt KMusEngSipReasonCodeTemporarilyNotAvailable = 480;

const TInt KMusEngSipReasonCodeBusyHere = 486;

const TInt KMusEngSipReasonCodeRequestCancelled = 487;

const TInt KMusEngSipReasonCodeNotAcceptableHere = 488;

const TInt KMusEngSipReasonCodeDecline = 603;

const TInt KMusEngSipReasonCodeNotAcceptable = 606;

// The next code represents unofficial sip error code

// "479 Regretfuly, we were not able to process the URI (479/SL)

const TInt KMusEngSipReasonCode479NotAbleToProcessURI = 479;

const TUint8 KMusEngPayloadTypeVideoH263 = 96;

const TUint8 KMusEngPayloadTypeAudio = 97;

const TUint8 KMusEngPayloadTypeVideoAvc = 98;

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

//

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

//

CMusEngMceOutSession::~CMusEngMceOutSession()

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngMceOutSession::~CMusEngMceOutSession()" )

    delete iRecipient;

    delete iVideoCodecList;

    MUS_LOG( "mus: [ENGINE]  <- CMusEngMceOutSession::~CMusEngMceOutSession()" )

    }

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

//

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

//

    {

    }

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

// Calls MCE function EstablishL with feature tag in Accept-Contact header.

// Adjusts stream and codec values.

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

//

void CMusEngMceOutSession::EstablishSessionL()

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngMceOutSession::EstablishSessionL()" )

    __ASSERT_ALWAYS( iSession, User::Leave( KErrNotReady ) );

    AdjustStreamsAndCodecsL();

    CDesC8Array* headers = new ( ELeave ) CDesC8ArrayFlat( 1 );

    CleanupStack::PushL( headers );

    headers->AppendL( KMusEngAcceptContactHeader() );

    headers->AppendL( KMusAcceptHeader() ); 

    if ( iOperatorVariant )

        {

        CUri8* originator = iSipProfileHandler->UserFromProfileLC();

        CSIPExtensionHeader* header = CSIPExtensionHeader::NewLC( 

                    KMusPPreferredIdentity, originator->Uri().UriDes() );

        HBufC8* headInText = header->ToTextL();

        MUS_LOG_TDESC8( " mus: [ENGINE] P-Preferred-Identity header : ", headInText->Des() );

        CleanupStack::PopAndDestroy( header );

        CleanupStack::PopAndDestroy( originator );

        CleanupStack::PushL( headInText );

        headers->AppendL( *headInText );

        CleanupStack::PopAndDestroy( headInText );

        }

    static_cast<CMceOutSession*>( iSession )->EstablishL( 0, headers );

    CleanupStack::Pop( headers );

    MUS_LOG( "mus: [ENGINE]  <- CMusEngMceOutSession::EstablishSessionL()" )

    }

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

// Handle MCE session termination. Called by MCE observer function of the

// base class.

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

//

void CMusEngMceOutSession::HandleTermination( TInt aStatusCode,

                                              const TDesC8& aReasonPhrase )

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngMceOutSession::HandleTermination()" )

    switch ( aStatusCode )

        {

            //lint -fallthrough

        case KMusEngSipReasonCode479NotAbleToProcessURI:

            //lint -fallthrough

        case KMusEngSipReasonCodeUnsupportedUriScheme : 

            {

            break;

            }

        case KMusEngSipReasonCodeRequestTimeout :

            {

            break;

            }

        case KMusEngSipReasonCodeUnsupportedMediaType :

            //lint -fallthrough

        case KMusEngSipReasonCodeNotAcceptableHere:

            //lint -fallthrough

        case KMusEngSipReasonCodeNotAcceptable:

            {

            break;

            }

        case KMusEngSipReasonCodeBusyHere :

            {

            // Operator variant uses 486 to rejection instead of 603

            if ( iOperatorVariant )

                {

                }

            else

                {

                }

            break;

            }

        case KMusEngSipReasonCodeRequestCancelled :  

            {

            break;

            }

        case KMusEngSipReasonCodeDecline :

            {

            break;

            }

        case KMusEngSipReasonCodeTemporarilyNotAvailable :

            {

            break;

            }

        default:

            {

            // Termination reason is not outsession specific.

            // Let the base class to handle the termination.

            CMusEngMceSession::HandleTermination( aStatusCode, aReasonPhrase );

            }

        }

    MUS_LOG( "mus: [ENGINE]  <- CMusEngMceOutSession::HandleTermination()" )

    }

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

// Sets payload type and calls overridden base class version

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

//

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngMceOutSession::AdjustVideoCodecL()" )

    if ( aVideoCodec.SdpName() == KMceSDPNameH263() ||

         aVideoCodec.SdpName() == KMceSDPNameH2632000() )

        {

        User::LeaveIfError( 

                aVideoCodec.SetPayloadType( KMusEngPayloadTypeVideoH263 ) );

        }

    else if ( aVideoCodec.SdpName() == KMceSDPNameH264() )

        {

        User::LeaveIfError(

                aVideoCodec.SetPayloadType( KMusEngPayloadTypeVideoAvc ) );

        }

    else

        {

        // NOP

        }

    MUS_LOG( "mus: [ENGINE]  <- CMusEngMceOutSession::AdjustVideoCodecL()" )

    }

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

// Sets payload type and calls overridden base class version

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

//        

void CMusEngMceOutSession::AdjustAudioCodecL( CMceAudioCodec& aAudioCodec )

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngMceOutSession::AdjustAudioCodecL()" )

    CMusEngMceSession::AdjustAudioCodecL( aAudioCodec );

    User::LeaveIfError( aAudioCodec.SetPayloadType( KMusEngPayloadTypeAudio ) );

    MUS_LOG( "mus: [ENGINE]  <- CMusEngMceOutSession::AdjustAudioCodecL()" )

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

//

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

//

    {

    }

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

//

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

//

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngMceOutSession::CreateMceSessionStructureL()" )

    __ASSERT_ALWAYS( profile != NULL, User::Leave( KErrNotReady ) );

    // Create session

    // Remove QoS-lines if needed

    if ( profile->Type().iSIPProfileClass == 

         TSIPProfileTypeInfo::EInternet ||

         MultimediaSharingSettings::ForceInternetSignalingSettingL() ==

         MusSettingsKeys::EForceInternetSignaling ||

         iOperatorVariant)

        {

        iSession->SetModifierL( KMcePreconditions, KMcePreconditionsNotUsed );

        MUS_LOG( "mus: [ENGINE]     Usage of preconditions denied" )

        }

    // Create bundle for local streams

    CMceStreamBundle* localBundle = 

                        CMceStreamBundle::NewLC( CMceStreamBundle::ELS );

    // To complete session structure, let the sibling classes add video out

    // and possibly needed audio streams

    CompleteSessionStructureL( *localBundle );

    // Create stream to display and share source with video outstream

    CMceVideoStream* streamForDisplay = CMceVideoStream::NewLC();

    CMceVideoStream* videoOut = MusEngMceUtils::GetVideoOutStreamL( *iSession );

    streamForDisplay->SetSourceL( videoOut->Source() );

    iSession->AddStreamL( streamForDisplay );

    CleanupStack::Pop( streamForDisplay );    

    // Check if there are audio streams to bundle with

    if ( localBundle->Streams().Count() > 0 ) 

        {

        localBundle->AddStreamL( *streamForDisplay );

        iSession->AddBundleL( localBundle );

        CleanupStack::Pop( localBundle );

        }

    else

        {

        CleanupStack::PopAndDestroy( localBundle );

        }

    MUS_LOG( "mus: [ENGINE]  <- CMusEngMceOutSession::CreateMceSessionStructureL()" )

    }