/*

* 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_musengcamerahandler.h"

#include "musengstubs.h"

#include "musengtestdefs.h"

#include "musenglivesession.h"

#include "mussipprofilehandler.h"

#include "musengmceutils.h"

#include "mussettings.h"

#include "mussessionproperties.h"

//  SYSTEM INCLUDES

#include <eunitmacros.h>

#include <mceoutsession.h>

#include <mcestreambundle.h>

#include <mcevideostream.h>

#include <mcecamerasource.h>

#include <mcertpsink.h>

#include <mcedisplaysink.h>

#include <mcertpsource.h>

const TUint KSipProfileId( 1 );

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

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

//

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

//

UT_TMusEngCameraHandler* UT_TMusEngCameraHandler::NewL()

    {

    UT_TMusEngCameraHandler* self = UT_TMusEngCameraHandler::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

//

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

//

UT_TMusEngCameraHandler* UT_TMusEngCameraHandler::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

//

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

//

UT_TMusEngCameraHandler::~UT_TMusEngCameraHandler()

    {

    // NOP

    }

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

// Default constructor

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

//

UT_TMusEngCameraHandler::UT_TMusEngCameraHandler()

    {

    // NOP

    }

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

// Second phase construct

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

//

void UT_TMusEngCameraHandler::ConstructL()

    {

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

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

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

//

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

//

void UT_TMusEngCameraHandler::SetupL()

    {

    iManager = CMceManager::NewL( TUid::Null(), NULL );

    iObserver = new( ELeave ) CMusEngObserverStub;

    iObserver->iRoamingBetweenAPsAllowed = ETrue;

    iProfileHandler = CMusSipProfileHandler::NewL( *iObserver );

    iProfileHandler->CreateProfileL( KSipProfileId );

    iSession = CMceOutSession::NewL( *iManager,

                                     *iProfileHandler->Profile(),

                                      KTestRecipientSipUri8() );

    CMceVideoStream* videoOut = CMceVideoStream::NewLC();

    videoOut->AddSinkL( CMceRtpSink::NewLC() );

    CleanupStack::Pop();

    videoOut->AddSinkL( CMceDisplaySink::NewLC( *iManager ) );

    CleanupStack::Pop();

    videoOut->SetSourceL( CMceCameraSource::NewLC( *iManager ) );

    CleanupStack::Pop();

    CMceVideoStream* videoIn  = CMceVideoStream::NewLC();

    CMceDisplaySink* receivingDisplay = CMceDisplaySink::NewLC( *iManager );

    videoIn->AddSinkL( receivingDisplay );

    CleanupStack::Pop();

    videoIn->SetSourceL( CMceRtpSource::NewLC() );

    CleanupStack::Pop();

    videoOut->BindL( videoIn );

    CleanupStack::Pop( videoIn );

    iSession->AddStreamL( videoOut );

    CleanupStack::Pop( videoOut ); 

    }

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

//

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

//

void UT_TMusEngCameraHandler::Teardown()

    {

    delete iSession;

    iSession = NULL;

    iCameraHandler.SetSession( NULL );

    delete iProfileHandler;

    delete iObserver;

    delete iManager;

    }

// TEST CASES

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

//

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

//

void UT_TMusEngCameraHandler::UT_LcCameraCountL()

    {

    // Call without setting the MCE session

    EUNIT_ASSERT_SPECIFIC_LEAVE( iCameraHandler.LcCameraCountL(), KErrNotReady )

    iCameraHandler.SetSession( iSession );

    CMceCameraSource* camera = 

        MusEngMceUtils::GetCameraL( *( iSession ) );

    iCameraHandler.iCameraUsage = MusSettingsKeys::EUseCameraSwapping;

    camera->iCameraCount = 2;

    camera->iCameraIndex = TMusEngCameraHandler::EBackCamera;

    // Two cameras

    EUNIT_ASSERT_EQUALS( 2, iCameraHandler.LcCameraCountL() )

    // Two cameras, swapping cameras not allowed, use only main camera

    iCameraHandler.iCameraUsage = MusSettingsKeys::EUseOnlyMainCamera;

    camera->iCameraCount = 2;

    EUNIT_ASSERT_EQUALS( 1, iCameraHandler.LcCameraCountL() )

    // Two cameras, swapping cameras not allowed, use only main camera

    iCameraHandler.iCameraUsage = MusSettingsKeys::EUseOnlySecondaryCamera;

    camera->iCameraCount = 2;

    EUNIT_ASSERT_EQUALS( 1, iCameraHandler.LcCameraCountL() )

    // Only one camera available

    iCameraHandler.iCameraUsage = MusSettingsKeys::EUseCameraSwapping;

    camera->iCameraCount = 1;

    EUNIT_ASSERT_EQUALS( 1, iCameraHandler.LcCameraCountL() ) 

    }

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

//

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

//

void UT_TMusEngCameraHandler::UT_ToggleLcCameraL()

    {

    EUNIT_ASSERT_EQUALS( TInt( TMusEngCameraHandler::ECameraNotAvailable ), 

                         iCameraHandler.CurrentLcCameraIndex() )     

    iCameraHandler.SetSession( iSession );

    iCameraHandler.iCameraUsage = MusSettingsKeys::EUseCameraSwapping;

    iCameraHandler.iCurrentCamera = TMusEngCameraHandler::EBackCamera;

    // Switch from back to front

    iCameraHandler.ToggleLcCameraL();

    EUNIT_ASSERT_EQUALS( TInt( TMusEngCameraHandler::EFrontCamera ), 

                         iCameraHandler.CurrentLcCameraIndex() )

    // Switch from front to back

    iCameraHandler.ToggleLcCameraL();

    EUNIT_ASSERT_EQUALS( TInt( TMusEngCameraHandler::EBackCamera ), 

                         iCameraHandler.CurrentLcCameraIndex() )    

    }

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

//

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

//

void UT_TMusEngCameraHandler::UT_MinLcZoomL()

    {

    // MCE Session has not been set

    EUNIT_ASSERT_SPECIFIC_LEAVE( iCameraHandler.MinLcZoomL(), KErrNotReady )

    // MCE Session has been set

    iCameraHandler.SetSession( iSession );

    EUNIT_ASSERT_EQUALS( 

        iCameraHandler.iCameraInfo.iMinZoom,

        iCameraHandler.MinLcZoomL() )

    }

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

//

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

//

void UT_TMusEngCameraHandler::UT_MaxLcZoomL()

    {

    // MCE Session has not been set

    EUNIT_ASSERT_SPECIFIC_LEAVE( iCameraHandler.MaxLcZoomL(), KErrNotReady )

    // MCE Session has been set

    iCameraHandler.SetSession( iSession );

    EUNIT_ASSERT_EQUALS( 

        iCameraHandler.iCameraInfo.iMaxZoom + 

        iCameraHandler.iCameraInfo.iMaxDigitalZoom,

        iCameraHandler.MaxLcZoomL() )

    }

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

//

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

//

void UT_TMusEngCameraHandler::UT_LcZoomValueL()

    {  

    // MCE Session has not been set

    EUNIT_ASSERT_SPECIFIC_LEAVE( iCameraHandler.LcZoomValueL(), KErrNotReady )

    // Check that originally current and default zoom are the same

    iCameraHandler.SetSession( iSession );

    CMceCameraSource* camera = MusEngMceUtils::GetCameraL( *( iSession ) );    

    // Zoom to maximum optical value

    while ( camera->iZoomFactor < iCameraHandler.iCameraInfo.iMaxZoom )

        {

        iCameraHandler.LcZoomInL();

        }   

    EUNIT_ASSERT_EQUALS( 

        iCameraHandler.iCameraInfo.iMaxZoom,

        iCameraHandler.LcZoomValueL() )   

    // Zoom using digital zoom

    iCameraHandler.LcZoomInL();

    EUNIT_ASSERT_EQUALS(

        iCameraHandler.iCameraInfo.iMaxZoom + camera->iDigitalZoomFactor,

        iCameraHandler.LcZoomValueL() )              

    }

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

//

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

//

void UT_TMusEngCameraHandler::UT_SetLcZoomValueL()

    {

    // MCE Session has not been set

    EUNIT_ASSERT_SPECIFIC_LEAVE( 

        iCameraHandler.SetLcZoomValueL( 1 ), 

        KErrNotReady )

    // Value above the maximum zoom

    iCameraHandler.SetSession( iSession );

    EUNIT_ASSERT_SPECIFIC_LEAVE( 

        iCameraHandler.SetLcZoomValueL( iCameraHandler.MaxLcZoomL() + 1 ), 

        KErrArgument )   

    // Value below the minimum zoom

    EUNIT_ASSERT_SPECIFIC_LEAVE( 

        iCameraHandler.SetLcZoomValueL( iCameraHandler.MinLcZoomL() - 1 ), 

        KErrArgument )     

    // OK: set zoom factor

    CMceCameraSource* camera = MusEngMceUtils::GetCameraL( *iSession );

    TInt zoomValue = iCameraHandler.iCameraInfo.iMaxZoom - 1;  

    iCameraHandler.SetLcZoomValueL( zoomValue );

    EUNIT_ASSERT_EQUALS( zoomValue, camera->ZoomFactorL() )     

    // OK: set digital zoom factor

    zoomValue = iCameraHandler.iCameraInfo.iMaxZoom + 1;

    iCameraHandler.SetLcZoomValueL( zoomValue );

    EUNIT_ASSERT_EQUALS( 1, camera->DigitalZoomFactorL() )  

    }

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

//

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

//

void UT_TMusEngCameraHandler::UT_LcZoomInL()

    {    

    // Check that zooming is not possible before invite

    TRAPD( error, iCameraHandler.LcZoomInL() );

    MUS_TEST_FORWARD_ALLOC_FAILURE( error );

    EUNIT_ASSERT( error == KErrNotReady );

    iCameraHandler.SetSession( iSession );

    CMceCameraSource* camera = MusEngMceUtils::GetCameraL( *( iSession ) );

    TInt oldZoomFactor = camera->iZoomFactor;

    // Check that zoom factor can be increased

    USER_SLEEP;  //insure that small step is used

    iCameraHandler.LcZoomInL();

    EUNIT_ASSERT( camera->iZoomFactor == oldZoomFactor +

            iCameraHandler.iSmallZoomStep );

   //Check the "burst" mode (immediate second ZoomIn), big step should be used

    TInt nZoom = camera->iZoomFactor + camera->iDigitalZoomFactor;

    iCameraHandler.LcZoomInL();

    TInt nStep = camera->iZoomFactor + camera->iDigitalZoomFactor - nZoom;

    EUNIT_ASSERT( nStep == iCameraHandler.iBigZoomStep );

    // Zoom to maximum optical value

    while ( camera->iZoomFactor < iCameraHandler.iCameraInfo.iMaxZoom )

        {

        iCameraHandler.LcZoomInL();

        }

    TInt maxOpticalZoomFactor = camera->ZoomFactorL();

    // Check that digital zoom is used instead of optical

    iCameraHandler.LcZoomInL();

    EUNIT_ASSERT( camera->iZoomFactor == maxOpticalZoomFactor );

    EUNIT_ASSERT( camera->iDigitalZoomFactor > 0 );

    // Zoom to maximum digital value

    while ( camera->iDigitalZoomFactor < 

            iCameraHandler.iCameraInfo.iMaxDigitalZoom )

        {

        iCameraHandler.LcZoomInL();

        }

    TInt maxDigitalZoomFactor = camera->DigitalZoomFactorL();

    // Check that further zooming is impossible

    iCameraHandler.LcZoomInL();

    EUNIT_ASSERT( camera->iZoomFactor == maxOpticalZoomFactor );

    EUNIT_ASSERT( camera->iDigitalZoomFactor == maxDigitalZoomFactor );   

    }

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

//

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

//

void UT_TMusEngCameraHandler::UT_LcZoomOutL()

    {

    // Check that zooming is not possible before invite

    TRAPD( error, iCameraHandler.LcZoomOutL() );

    MUS_TEST_FORWARD_ALLOC_FAILURE( error );

    EUNIT_ASSERT( error == KErrNotReady );

    iCameraHandler.SetSession( iSession );

    CMceCameraSource* camera = 

                        MusEngMceUtils::GetCameraL( *(iSession) );

    // Simulate maximum zoom 

    camera->iZoomFactor = iCameraHandler.iCameraInfo.iMaxZoom;

    camera->iDigitalZoomFactor = iCameraHandler.iCameraInfo.iMaxDigitalZoom;

    // Check that digital zoom factor can be decreased

    USER_SLEEP;  //insure that small step is used

    iCameraHandler.LcZoomOutL();

    EUNIT_ASSERT( camera->iZoomFactor == iCameraHandler.iCameraInfo.iMaxZoom );

    EUNIT_ASSERT( camera->iDigitalZoomFactor == 

                    iCameraHandler.iCameraInfo.iMaxDigitalZoom - 

                    iCameraHandler.iSmallZoomStep );

    //Check the "burst" mode (immediate second ZoomOut), big step should be used

    TInt nZoom = camera->iZoomFactor + camera->iDigitalZoomFactor;

    iCameraHandler.LcZoomOutL();

    TInt nStep;

    nStep = nZoom - (camera->iZoomFactor + camera->iDigitalZoomFactor );

    EUNIT_ASSERT( nStep == iCameraHandler.iBigZoomStep );

    // Simulate maximum zoom again

    camera->iZoomFactor = iCameraHandler.iCameraInfo.iMaxZoom;

    camera->iDigitalZoomFactor = iCameraHandler.iCameraInfo.iMaxDigitalZoom;

    // Zoom to minimum digital zoom

    while ( camera->iDigitalZoomFactor > 0 )

        {

        iCameraHandler.LcZoomOutL();

        }

    EUNIT_ASSERT( camera->iZoomFactor == iCameraHandler.iCameraInfo.iMaxZoom );

    EUNIT_ASSERT( camera->iDigitalZoomFactor == 0 );

    // Check that optical zoom is decreased instead of digital

    USER_SLEEP;  //insure that step is the small one

    iCameraHandler.LcZoomOutL();

    EUNIT_ASSERT( camera->iZoomFactor == 

                    iCameraHandler.iCameraInfo.iMaxZoom -

                    iCameraHandler.iSmallZoomStep );

    EUNIT_ASSERT( camera->iDigitalZoomFactor == 0 );

    // Zoom to minimum optical zoom

    while ( camera->iZoomFactor > iCameraHandler.iCameraInfo.iMinZoom )

        {

        iCameraHandler.LcZoomOutL();

        }

    // Check that further zooming is impossible

    iCameraHandler.LcZoomOutL();

    EUNIT_ASSERT( camera->iZoomFactor == iCameraHandler.iCameraInfo.iMinZoom );

    EUNIT_ASSERT( camera->iDigitalZoomFactor == 0 );

    }

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

//

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

//

void UT_TMusEngCameraHandler::UT_SetLcBrightnessL()

    {

    // Check that setting brightness is not possible before invite

    EUNIT_ASSERT_SPECIFIC_LEAVE( 

        iCameraHandler.SetLcBrightnessL( KTestSomeBrightness ),

        KErrNotReady )

    iCameraHandler.SetSession( iSession );

    CMceCameraSource* camera = MusEngMceUtils::GetCameraL( *( iSession ) );

    camera->iCameraInfo.iOptionsSupported =

        camera->iCameraInfo.iOptionsSupported|TCameraInfo::EBrightnessSupported;

    // Check that originally current and default brightness are the same

    EUNIT_ASSERT_EQUALS( iCameraHandler.iDefaultBrightness,

                         iCameraHandler.LcBrightnessL() )

    // Test setting brightness

    iCameraHandler.SetLcBrightnessL( KTestSomeBrightness );

    EUNIT_ASSERT_EQUALS( KTestSomeBrightness, iCameraHandler.LcBrightnessL() )

    }

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

//

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

//

void UT_TMusEngCameraHandler::UT_LcBrightnessL()

    {

    // Check that checking current brightness is not possible before invite

    EUNIT_ASSERT_SPECIFIC_LEAVE( iCameraHandler.LcBrightnessL(),

                                 KErrNotReady )

    // All the other stuff checked in tests of SetBrightnessL

    }

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

//

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

//

void UT_TMusEngCameraHandler::UT_MaxLcBrightnessL()

    {

    // MaxBrightness should return a constant

    EUNIT_ASSERT_EQUALS( KTestMaxBrightness, iCameraHandler.MaxLcBrightnessL() )

    }

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

//

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

//

void UT_TMusEngCameraHandler::UT_MinLcBrightnessL()

    {

    // MinBrightness should return a constant

    EUNIT_ASSERT_EQUALS( KTestMinBrightness, iCameraHandler.MinLcBrightnessL() )

    }

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

//

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

//

void UT_TMusEngCameraHandler::UT_IncreaseLcBrightnessL()

    {

    // Check that increasing brightness is not possible before invite

    EUNIT_ASSERT_SPECIFIC_LEAVE( iCameraHandler.IncreaseLcBrightnessL(),

                                 KErrNotReady )

    iCameraHandler.SetSession( iSession );

    CMceCameraSource* camera = MusEngMceUtils::GetCameraL( *(iSession) );

    camera->iCameraInfo.iOptionsSupported =

        camera->iCameraInfo.iOptionsSupported|TCameraInfo::EBrightnessSupported;