/*

* 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"

#include "mussessionproperties.h"

#include "musresourceproperties.h"

// SYSTEM

#include <lcsessionobserver.h>

#include <lcuiprovider.h>

#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 <e32property.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;

const TInt KMusEngSipAddressMaxLength = 256;

const TInt KMusEngSipAddressesMaxAmount  =   8;

_LIT( KMusEngCommaSymbol, "," );

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

//

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

//

CMusEngMceOutSession::CMusEngMceOutSession()

    : CMusEngMceSession(),

      iTriedInvitations( 0 ),

      iAsyncBrakeCallBack( AsyncBrakeCompleted, this ),

      iRegistrationCallBack( RegistrationTimerExpired, this ),

      iInvitationResponseCallBack( InvitationResponseTimerExpired, this )

    {

    iAsyncBrakeEntry.Set( iAsyncBrakeCallBack );

    iRegistrationEntry.Set( iRegistrationCallBack );

    iInvitationResponseEntry.Set( iInvitationResponseCallBack );

    }

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

//

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

//

void CMusEngMceOutSession::ConstructL()

    {

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

    CMusEngMceSession::ConstructL();

    TInt sipProfileId;

    TInt error = KErrNone;

    error = ( RProperty::Get( NMusSessionApi::KCategoryUid, 

                             NMusSessionApi::KSipProfileId, sipProfileId ) );

    if ( error != KErrNone )

       {

       sipProfileId = KErrNone;

       error = KErrNone;

       }

    iSipProfileHandler->CreateProfileL( sipProfileId );

    iVideoCodecList = NULL;

    TBuf<RProperty::KMaxPropertySize> buffer;

    error = ( RProperty::Get( NMusSessionApi::KCategoryUid, 

                                 NMusSessionApi::KVideoCodecs, buffer ) );

    if ( error == KErrNone && buffer.Length() )

        {

        iVideoCodecList = 

                    CnvUtfConverter::ConvertFromUnicodeToUtf8L( buffer );

        }

    iDeltaTimer = CDeltaTimer::NewL( CActive::EPriorityStandard );

    /* Read the contact name set by availability plugin */    

    error = RProperty::Get( NMusSessionApi::KCategoryUid,

                                 NMusSessionApi::KContactName,

                                 buffer );

    iRemoteDisplayName = ( error == KErrNone && buffer.Length() ) 

                         ? buffer.AllocL() : KNullDesC().AllocL();

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

    }

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

//

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

//

CMusEngMceOutSession::~CMusEngMceOutSession()

    {

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

    if ( iAddressQueried && iRecipient )

        {

        TRAP_IGNORE( SaveContactL( *iRecipient ) )

        }

    delete iDeltaTimer;

    delete iRecipient;

    delete iVideoCodecList;

    delete iRemoteSipAddressProposal;

    delete iRemoteDisplayName;

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

    }

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

// From MLcSession

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

//

void CMusEngMceOutSession::EstablishLcSessionL()

    {

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

    iAddressQueried = EFalse;

    if ( LcUiProvider() && !IsBackgroundStartup() )

        {

        LcUiProvider()->HandleForegroundStatus( ETrue );

        }

    TRAPD( err, DoInviteL() );

    // If address is in wrong format, Manual Address Entry Dialog is displayed

    if ( ( err == KErrArgument ) && DoSyncRetryL() )

        {  

        err = KErrNone; // Doing retry

        }

    User::LeaveIfError( err );

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

    }

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

// From MLcSession

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

//

void CMusEngMceOutSession::TerminateLcSessionL()

    {

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

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

    if( iSession->State() == CMceSession::EOffering )

        {

        static_cast< CMceOutSession* >( iSession )->CancelL();

        }

    else

        {

        iSession->TerminateL();

        }

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

    }

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

//

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

//

void CMusEngMceOutSession::AddDisplayL( CMceMediaStream& aStream )

    {

    MusEngMceUtils::AddDisplayL( aStream, *iManager, Rect() );

    }

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

// 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 )

        {

        case KMusEngSipReasonCodeRecipientNotFound : 

            //lint -fallthrough

        case KMusEngSipReasonCode479NotAbleToProcessURI:

            //lint -fallthrough

        case KMusEngSipReasonCodeUnsupportedUriScheme : 

            {

            InitRecipientNotFoundHandling();

            break;

            }

        case KMusEngSipReasonCodeRequestTimeout :

            {

            InformObserverAboutSessionFailure( MLcSession::ENoAnswer );

            break;

            }

        case KMusEngSipReasonCodeUnsupportedMediaType :

            //lint -fallthrough

        case KMusEngSipReasonCodeNotAcceptableHere:

            //lint -fallthrough

        case KMusEngSipReasonCodeNotAcceptable:

            {

            InformObserverAboutSessionFailure( MLcSession::ESessionRejected );

            break;

            }

        case KMusEngSipReasonCodeBusyHere :

            {

            // Operator variant uses 486 to rejection instead of 603

            if ( iOperatorVariant )

                {

                InformObserverAboutSessionFailure( 

                    MLcSession::ESessionRejected );

                }

            else

                {

                InformObserverAboutSessionFailure( 

                    MLcSession::ERecipientBusy );

                }

            break;

            }

        case KMusEngSipReasonCodeRequestCancelled :  

            {

            InformObserverAboutSessionFailure( MLcSession::ESessionCancelled );

            break;

            }

        case KMusEngSipReasonCodeDecline :

            {

            InformObserverAboutSessionFailure( MLcSession::ESessionRejected );

            break;

            }

        case KMusEngSipReasonCodeTemporarilyNotAvailable :

            {

            InformObserverAboutSessionFailure( 

                MLcSession::ERecipientTemporarilyNotAvailable );

            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

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

//

void CMusEngMceOutSession::AdjustVideoCodecL( CMceVideoCodec& aVideoCodec,

                                              TMceSourceType aSourceType )

    {

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

    CMusEngMceSession::AdjustVideoCodecL( aVideoCodec, aSourceType );

    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()" )

    }  

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

//

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

//

void CMusEngMceOutSession::ProfileRegistered()

    {

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

    if ( iRegistrationPending )

        {

        iDeltaTimer->Remove( iRegistrationEntry );

        iRegistrationPending = EFalse;

        HBufC* resolvedRecipient = NULL;

        TRAPD( error, resolvedRecipient = RemoteAddressL() )

        if ( error != KErrNone )

            {

            InformObserverAboutSessionFailure( error );

            }

        else

            {

            TRAP( error, DoInviteL( *resolvedRecipient ) )

            delete resolvedRecipient; 

            if ( error != KErrNone )

                {

                InformObserverAboutSessionFailure( error );

                }

            }

        }

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

    }

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

//

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

//

TBool CMusEngMceOutSession::IsH264Supported() const

    {

    return ( iVideoCodecList && iVideoCodecList->FindF( KMceSDPNameH264() ) >= 0 );

    }

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

//

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

//

void CMusEngMceOutSession::CreateMceSessionStructureL( TBool aForceSdpBandwidth )

    {

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

    CSIPProfile* profile = iSipProfileHandler->Profile();

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

    // Create session

    iSession = CMceOutSession::NewL( *iManager, *profile, *iRecipient );

    // 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" )

        }

    SetSessionSdpLinesL( *iSession, aForceSdpBandwidth );

    // 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 );

    SetMediaSdpLinesL( *videoOut, aForceSdpBandwidth );

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

    AddDisplayL( *streamForDisplay );

    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()" )

    }

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

//

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

//

void CMusEngMceOutSession::DoInviteL( const TDesC& aRecipient )

    {

    MUS_LOG_TDESC( "mus: [ENGINE]  -> CMusEngMceOutSession::DoInviteL(): ",

                   aRecipient ) 

    HBufC* resolvedRecipient = NULL;

    if ( aRecipient.Length() > 0 )

        {

        resolvedRecipient = aRecipient.AllocLC();

        }

    else

        {

        resolvedRecipient = ResolveRecipientLC();

        }

    // delete possibly existing recipient

    delete iRecipient;

    iRecipient = NULL;  

    TMusEngUriParser parser( *resolvedRecipient ); 

    parser.ParseUriL();    

    iRecipient = parser.GetUri8L();    

    /* Set the display name to recipient address if displayname is empty */

    if ( !iRemoteDisplayName || iRemoteDisplayName->Length() == 0 )

        {

        HBufC* tmp = parser.GetUri16L( ETrue );

        delete iRemoteDisplayName;

        iRemoteDisplayName = tmp;

        }

    CleanupStack::PopAndDestroy( resolvedRecipient );

    if ( iSession )

        {

        MUS_ENG_LOG_SESSION_STATE( *iSession ) 

        if ( iSession->State() == CMceSession::EIdle ||

             iSession->State() == CMceSession::ETerminated )

            {

            // This is the case when last invite has ended up to an error,

            // last sharing has ended normally, or construction of the session

            // stucture has not been completed. Delete old session and try to

            // continue normally.

            delete iSession;

            iSession = NULL;

            MUS_LOG( "mus: [ENGINE]     Existing session deleted")

            }