/*

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

*

*/

//  INTERNAL INCLUDES

#include "ut_musengtwowaysession.h"

#include "musengstubs.h"

#include "musengtestdefs.h"

#include "musengtwowaysession.h"

#include "mussipprofilehandler.h"

#include "musengmceutils.h"

#include "mussettings.h"

#include "mussessionproperties.h"

#include "musengremotevideoplayer.h"

//  SYSTEM INCLUDES

#include <eunitmacros.h>

#include <mceoutsession.h>

#include <mcestreambundle.h>

#include <mcevideostream.h>

#include <mcecamerasource.h>

#include <mcertpsink.h>

#include <mcefilesink.h>

#include <mceh263codec.h>

#include <mceavccodec.h>

#include <mceaudiocodec.h>

#include <mcedisplaysink.h>

#include <mcertpsource.h>

_LIT8( KMusAvcBitrateLevel1TestText, "TestTextForAvcBrL1Level" );

_LIT8( KMusAvcBitrateLevel1bTestText, "TestTextForAvcBrL1bLevel" );

_LIT8( KMusAvcBitrateLevel1_1TestText, "TestTextForAvcBrL1_1Level" );

_LIT8( KMusAvcBitrateLevel1_2TestText, "TestTextForAvcBrL1_2Level" );

_LIT8( KMusAvcBitrateLevel1_3TestText, "TestTextForAvcBrL1_3Level" );

_LIT8( KMusAvcBitrateLevel2TestText, "TestTextForAvcBrL2Level" );

_LIT8( KMusAvcBitrateLevel_1b_ConfigKey, "AvcBrL1b=TestTextForAvcBrL1bLevel;" );

_LIT8( KMusAvcBitrateLevel_1_1_ConfigKey, 

"AvcBrL1_1=TestTextForAvcBrL1_1Level;");

_LIT8( KMusAvcBitrateLevels_1_1_And_1b_ConfigKeys, 

"AvcBrL1_1=TestTextForAvcBrL1_1Level;\

AvcBrL1b=TestTextForAvcBrL1bLevel;" );

_LIT8( KMusAvcAllLevelsConcatenation,

"AvcBrL1=TestTextForAvcBrL1Level;\

AvcBrL1b=TestTextForAvcBrL1bLevel;\

AvcBrL1_1=TestTextForAvcBrL1_1Level;\

AvcBrL1_2=TestTextForAvcBrL1_2Level;\

AvcBrL1_3=TestTextForAvcBrL1_3Level;\

AvcBrL2=TestTextForAvcBrL2Level;" );

//use step in different time period

const TInt KZoomBigStepCount = 15;

const TInt KZoomSmallStepCount = KZoomBigStepCount*2;

const TInt KZoomStepMinSize = 1;

// 0.4 second

const TInt64 KZoomFasterTime = 400000;//must bigger than 1/3 second

//insure that step is 1

#define USER_SLEEP  User::After(KZoomFasterTime)

// NOTE!!!!!!!!!!

// There are intentianally many same cases as already in CMusEngLiveSession 

// as two-way session derives from livesession. These cases therefore

// ensure that live session changes are not breaking two-way session.

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

//

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

//

UT_CMusEngTwoWaySession* UT_CMusEngTwoWaySession::NewL()

    {

    UT_CMusEngTwoWaySession* self = UT_CMusEngTwoWaySession::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

//

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

//

UT_CMusEngTwoWaySession* UT_CMusEngTwoWaySession::NewLC()

    {

    UT_CMusEngTwoWaySession* self = new( ELeave ) UT_CMusEngTwoWaySession();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

//

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

//

UT_CMusEngTwoWaySession::~UT_CMusEngTwoWaySession()

    {

    // NOP

    }

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

// Default constructor

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

//

UT_CMusEngTwoWaySession::UT_CMusEngTwoWaySession()

    {

    // NOP

    }

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

// Second phase construct

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

//

void UT_CMusEngTwoWaySession::ConstructL()

    {

    // The ConstructL from the base class CEUnitTestSuiteClass must be called.

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

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

//

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

//

void UT_CMusEngTwoWaySession::SetupL()

    {

    iLcSessionObserver = new( ELeave )CLcSessionObserverStub;

    iLcUiProvider = new( ELeave )CLcUiProviderStub;    

    iLiveSession = CMusEngTwoWaySession::NewL();

    iLiveSession->SetLcSessionObserver( iLcSessionObserver );

    iLiveSession->SetLcUiProvider( iLcUiProvider );    

    User::LeaveIfError( RProperty::Set( NMusSessionApi::KCategoryUid,

                                        NMusSessionApi::KRemoteSipAddress,

                                        KTestRecipientSipUri ) );

    }

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

//

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

//

void UT_CMusEngTwoWaySession::Teardown()

    {

    delete iLiveSession;

    delete iLcSessionObserver;

    delete iLcUiProvider;

    PropertyHelper::Close();

    // Delete static data from CenRep stub

    CRepository::iStaticWriteAvcKeysToStaticData = EFalse;

    CRepository::DeleteStubAvcConfigKeys();

    CRepository::ResetStubGlobal();

    CRepository::iForceFailWithCode = KErrNone;

    }

// TEST CASES

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

//

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

//

void UT_CMusEngTwoWaySession::UT_NewLL()

    {

    EUNIT_ASSERT( iLiveSession )

    EUNIT_ASSERT( iLiveSession->iCameraHandler.iCameraUsage == MusSettingsKeys::EUseCameraSwapping );     

    EUNIT_ASSERT( iLiveSession->iMceManagerUid == TUid::Uid( KMusUiUid ) );

    delete iLiveSession;

    iLiveSession = NULL;

    CRepository::SetStubGlobal( MusSettingsKeys::KCameraUsage,

                                MusSettingsKeys::EUseOnlySecondaryCamera );

    iLiveSession = CMusEngTwoWaySession::NewL();   

    EUNIT_ASSERT( iLiveSession->iCameraHandler.iCameraUsage == MusSettingsKeys::EUseOnlySecondaryCamera );     

    delete iLiveSession;

    iLiveSession = NULL;

    CRepository::SetStubGlobal( MusSettingsKeys::KCameraUsage,

                                MusSettingsKeys::EUseOnlyMainCamera );

    iLiveSession = CMusEngTwoWaySession::NewL();  

    EUNIT_ASSERT_EQUALS( TInt( MusSettingsKeys::EUseOnlyMainCamera ),

                         TInt( iLiveSession->iCameraHandler.iCameraUsage ) )      

    }

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

//

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

//

void UT_CMusEngTwoWaySession::UT_EstablishLcSessionLL()

    {

    CRepository::SetStubGlobal( MusSettingsKeys::KVideoBandwidth,

                                128 );

    iLiveSession->EstablishLcSessionL();

    EUNIT_ASSERT( iLiveSession->iSession );

    // Next assertion ensures that session structure is new

    EUNIT_ASSERT( iLiveSession->iSession->Streams().Count() > 0 );   

    EUNIT_ASSERT( iLiveSession->iSession->Streams()[0] ); 

    EUNIT_ASSERT( *(iLiveSession->iRecipient) == KTestRecipientSipUri8() );

    EUNIT_ASSERT( iLiveSession->iSession->State() == CMceSession::EOffering );

    EUNIT_ASSERT( iLiveSession->iSession->iHeaders );

    EUNIT_ASSERT( iLiveSession->iSession->iHeaders->Count() == 2 );

    EUNIT_ASSERT( iLiveSession->iSession->iHeaders->MdcaPoint( 0 ) ==

                  KMusEngAcceptContactHeader() );

    EUNIT_ASSERT( iLiveSession->iSession->iHeaders->MdcaPoint( 1 ) ==

                  KMusAcceptHeader() );

    // Ensure there is no SDP lines at session level

    EUNIT_ASSERT( iLiveSession->iSession->iSessionSDPLines );

    EUNIT_ASSERT( iLiveSession->iSession->iSessionSDPLines->Count() == 1 );

    EUNIT_ASSERT( iLiveSession->iSession->iSessionSDPLines->MdcaPoint( 0 ) ==

                  KMusEngSessionSdpLineXApplication() );

    // Ensure b=AS and b=TIAS attributes are taken at media level   

    MDesC8Array* mediaSdpLines = 

        iLiveSession->iSession->Streams()[0]->iMediaSDPLines;

    EUNIT_ASSERT( mediaSdpLines );

    EUNIT_ASSERT( mediaSdpLines->MdcaCount() == 2 );

    EUNIT_ASSERT( mediaSdpLines->MdcaPoint( 0 ).Find( 

                  KMusEngSessionSdpLineBandwidthLine() ) == 0 );

    EUNIT_ASSERT( mediaSdpLines->MdcaPoint( 1 ).Find( 

                  KMusEngSessionSdpLineTiasLine() ) == 0 ); 

    }

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

//

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

//

void UT_CMusEngTwoWaySession::UT_EnableDisplayLL()

    {

    TRAPD( error, iLiveSession->EnableDisplayL( ETrue ) );

    MUS_TEST_FORWARD_ALLOC_FAILURE( error );

    EUNIT_ASSERT( error == KErrNotReady );

    ESTABLISH_OUT_SESSION( iLiveSession );

    CMceDisplaySink* display = 

                    MusEngMceUtils::GetDisplayL( *(iLiveSession->iSession) );

    CMceDisplaySink* receivingDisplay = 

                    MusEngMceUtils::GetReceivingDisplayL( *iLiveSession->iSession );

    // Disable

    iLiveSession->EnableDisplayL( EFalse );

    EUNIT_ASSERT( !display->iIsEnabled );

    EUNIT_ASSERT( !receivingDisplay->iIsEnabled );

    // Try to disable again, request should be ignored

    iLiveSession->EnableDisplayL( EFalse );

    EUNIT_ASSERT( !display->iIsEnabled );

    EUNIT_ASSERT( !receivingDisplay->iIsEnabled );

    // Enable

    iLiveSession->EnableDisplayL( ETrue );

    EUNIT_ASSERT( display->iIsEnabled );

    EUNIT_ASSERT( receivingDisplay->iIsEnabled );

    // Try to enable again, request should be ignored

    iLiveSession->EnableDisplayL( ETrue );

    EUNIT_ASSERT( display->iIsEnabled );

    EUNIT_ASSERT( receivingDisplay->iIsEnabled );

    // Display is active only if receiving and display is explicitly enabled

    EUNIT_ASSERT( !iLiveSession->IsDisplayActive() )

    iLiveSession->iReceiving = ETrue;

    EUNIT_ASSERT( iLiveSession->IsDisplayActive() )

    }

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

//

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

//

void UT_CMusEngTwoWaySession::UT_SetOrientationLL()

    {

    // Try without session, fails

    EUNIT_ASSERT_SPECIFIC_LEAVE( iLiveSession->SetOrientationL( 

                                               CMusEngMceSession::EPortrait ), 

                                KErrNotReady )

    // Establish a session

    ESTABLISH_OUT_SESSION( iLiveSession )

    CMceDisplaySink* display = 

                   MusEngMceUtils::GetDisplayL( *iLiveSession->iSession );

    CMceDisplaySink* receivingDisplay = 

                   MusEngMceUtils::GetReceivingDisplayL( *iLiveSession->iSession );

    // Check the initial state

    display->iRotation = CMceDisplaySink::ENone;

    receivingDisplay->iRotation = CMceDisplaySink::ENone;

    EUNIT_ASSERT_EQUALS( iLiveSession->OrientationL(), 

                         MLcWindow::EPortrait )      

    // Successfully change orientation

    iLiveSession->SetOrientationL( CMusEngMceSession::ELandscape );

    EUNIT_ASSERT_EQUALS( iLiveSession->OrientationL(), 

                         MLcWindow::ELandscape )

    EUNIT_ASSERT_EQUALS( display->iRotation, CMceDisplaySink::EClockwise90Degree );

    EUNIT_ASSERT_EQUALS( receivingDisplay->iRotation, CMceDisplaySink::EClockwise90Degree );

    iLiveSession->SetOrientationL( CMusEngMceSession::EPortrait );

    EUNIT_ASSERT_EQUALS( iLiveSession->OrientationL(), 

                         MLcWindow::EPortrait )          

    EUNIT_ASSERT_EQUALS( display->iRotation, CMceDisplaySink::ENone );

    EUNIT_ASSERT_EQUALS( receivingDisplay->iRotation, CMceDisplaySink::ENone );

    }

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

//

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

//

void UT_CMusEngTwoWaySession::UT_SetLocalRectLL()

    {

    // Does nothing real before session establishment

    TRect rect1( 100, 200, 300, 500 );

    iLiveSession->SetSecondaryRectL( rect1 ); 

    EUNIT_ASSERT( rect1 == iLiveSession->iLocalRect );

    // Local rect changing affects to viewfinder display sink not to receiving video

    //

    ESTABLISH_OUT_SESSION( iLiveSession );

    CMceDisplaySink* vfDisplay = 

                   MusEngMceUtils::GetDisplayL( *( iLiveSession->iSession ) );

    CMceDisplaySink* receivingDisplay = 

                   MusEngMceUtils::GetReceivingDisplayL( *( iLiveSession->iSession ) );

    EUNIT_ASSERT( vfDisplay->DisplayRectL() == iLiveSession->iLocalRect );

    EUNIT_ASSERT( receivingDisplay->DisplayRectL() != iLiveSession->iLocalRect );

    TRect rect2( 200, 200, 300, 500 );

    iLiveSession->SetSecondaryRectL( rect2 ); 

    EUNIT_ASSERT( rect2 == iLiveSession->iLocalRect );

    EUNIT_ASSERT( vfDisplay->DisplayRectL() == iLiveSession->iLocalRect );

    EUNIT_ASSERT( receivingDisplay->DisplayRectL() != iLiveSession->iLocalRect );

    // Terminate session and try again, rect must not be changed

    iLiveSession->iSession->iState = CMceSession::ETerminated;

    TRect rect3( 300, 300, 400, 600 );

    iLiveSession->SetSecondaryRectL( rect3 ); 

    EUNIT_ASSERT( vfDisplay->DisplayRectL() != rect3 )

    }

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

//

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

//

void UT_CMusEngTwoWaySession::UT_SetRectsLL()

    {

    // Does nothing real before session establishment

    TRect localrect1( 100, 200, 300, 400 );

    TRect remoterect1( 100, 200, 300, 500 );

    iLiveSession->SetRectsL( remoterect1, localrect1 ); 

    EUNIT_ASSERT( localrect1 == iLiveSession->iLocalRect );

    EUNIT_ASSERT( remoterect1 == iLiveSession->iRect );

    // Local rect changing affects to viewfinder display sink and remote rect to

    // receiving video display sink

    //

    ESTABLISH_OUT_SESSION( iLiveSession );

    CMceDisplaySink* vfDisplay = 

                   MusEngMceUtils::GetDisplayL( *( iLiveSession->iSession ) );

    CMceDisplaySink* receivingDisplay = 

                   MusEngMceUtils::GetReceivingDisplayL( *( iLiveSession->iSession ) );

    TRect localrect2( 200, 200, 300, 400 );

    TRect remoterect2( 200, 200, 300, 500 );

    EUNIT_ASSERT( vfDisplay->DisplayRectL() != localrect2 );

    EUNIT_ASSERT( receivingDisplay->DisplayRectL() != remoterect2 );

    iLiveSession->SetRectsL( remoterect2, localrect2 ); 

    EUNIT_ASSERT( localrect2 == iLiveSession->iLocalRect );

    EUNIT_ASSERT( remoterect2 == iLiveSession->iRect );

    EUNIT_ASSERT( vfDisplay->DisplayRectL() == iLiveSession->iLocalRect );

    EUNIT_ASSERT( receivingDisplay->DisplayRectL() == iLiveSession->iRect );

    // Terminate session and try again, rect must not be changed

    iLiveSession->iSession->iState = CMceSession::ETerminated;

    TRect localrect3( 300, 200, 300, 400 );

    TRect remoterect3( 300, 200, 300, 500 );

    iLiveSession->SetRectsL( remoterect3, localrect3 );

    EUNIT_ASSERT( vfDisplay->DisplayRectL() != localrect3 )

    EUNIT_ASSERT( receivingDisplay->DisplayRectL() != remoterect3 );

    }

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

//

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

//

void UT_CMusEngTwoWaySession::UT_EnableLcFileL()

    {

    // Recording is not supported for two-way session

    EUNIT_ASSERT_SPECIFIC_LEAVE( iLiveSession->EnableLcFileL( ETrue ),

                                 KErrNotSupported )

    }

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

//

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

//

void UT_CMusEngTwoWaySession::UT_CompleteSessionStructureLL()

    {

    CMceStreamBundle* localBundle = 

                            CMceStreamBundle::NewLC( CMceStreamBundle::ELS );

    // Check that structure cannot be completed before creating the session

    TRAPD( error, iLiveSession->CompleteSessionStructureL( *localBundle ) );

    MUS_TEST_FORWARD_ALLOC_FAILURE( error );

    EUNIT_ASSERT( error == KErrNotReady );

    // Normal case

    CSIPProfile* profile = iLiveSession->iSipProfileHandler->Profile();

    iLiveSession->iSession = CMceOutSession::NewL( 

                                    *(iLiveSession->iManager),

                                    *profile,

                                    KTestRecipientSipUri8() );

    iLiveSession->CompleteSessionStructureL( *localBundle );

    EUNIT_ASSERT( localBundle->Streams().Count() == 0 )

    EUNIT_ASSERT( iLiveSession->iSession->Streams().Count() == 1 );

    EUNIT_ASSERT( iLiveSession->iSession->Streams()[0]->Type() == KMceVideo );

    EUNIT_ASSERT( iLiveSession->iSession->Streams()[0]->Source() );

    EUNIT_ASSERT( iLiveSession->iSession->Streams()[0]->Source()->Type() ==

                  KMceCameraSource );

    EUNIT_ASSERT( iLiveSession->iSession->Streams()[0]->Sinks().Count() == 1 );

    EUNIT_ASSERT( iLiveSession->iSession->Streams()[0]->Sinks()[0]->Type() ==

                  KMceRTPSink );

    EUNIT_ASSERT( iLiveSession->iCameraHandler.iCurrentCamera ==

                        TMusEngCameraHandler::EBackCamera );

    CMceVideoStream* vidStream = static_cast<CMceVideoStream*>( iLiveSession->iSession->Streams()[0] );

    EUNIT_ASSERT( vidStream->BoundStream() );

    CMceVideoStream& inStream = static_cast<CMceVideoStream&>( vidStream->BoundStreamL() );

    EUNIT_ASSERT( inStream.Source() );

    EUNIT_ASSERT( inStream.Source()->Type() == KMceRTPSource );

    EUNIT_ASSERT( inStream.Sinks().Count() == 1 );

    EUNIT_ASSERT( inStream.Sinks()[0]->Type() == KMceDisplaySink );

    delete iLiveSession->iSession; 

    iLiveSession->iSession = NULL; 

    iLiveSession->iSession = CMceOutSession::NewL( 

                                    *(iLiveSession->iManager),

                                    *profile,

                                    KTestRecipientSipUri8() );

    iLiveSession->iCameraHandler.iCameraUsage = MusSettingsKeys::EUseOnlySecondaryCamera;     

    iLiveSession->CompleteSessionStructureL( *localBundle );

    EUNIT_ASSERT( iLiveSession->iCameraHandler.iCurrentCamera ==

                        TMusEngCameraHandler::EFrontCamera );

    CleanupStack::PopAndDestroy( localBundle );                                

    }

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

//

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

//

void UT_CMusEngTwoWaySession::UT_HandleSessionStateChangedL()

    {

    // Make Repository empty, config keys must be written

    CRepository::SetStubAvcConfigKeysL( KNullDesC8() );

    // Invite