/*

* Copyright (c) 2004-2007 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:  Local video configuration

*

*/

// INCLUDE FILES

#include    "CVtEngLocalVideo.h"

#include    "CVtEngMediaHandler.h"

#include    "VtEngPanic.h"

#include    "MVtEngFrameObserver.h"

#include    "CVtEngStateManager.h"

#include    "CVtEngEventManager.h"

#include    "MVtEngMedia.h"

#include    "CVtEngSettings.h"

#include    "VtEngUtils.h"

#include    "VtEngEvents.h"

#include    <videotelephonydomainpskeys.h>

#include    <videotelephonyvariant.hrh>

#include    <capivideosource.h>

#include    <cvtlogger.h>

#include    <mvtprotocolhandler.h>

#include    "CVtEngCameraPreferences.h"

// LOCAL CONSTANTS AND MACROS

// Maximum count of providers stored (cameras, still, blank)

const TInt KVtEngProviderCountMax = 4;

// Max zoom step count.

const TInt KVtMaxZoomStep = 10;

// If prepare camera is called when provider is ready signal

// immediately back with positive value.

const TInt KVtEngAlreadySelected = 1;

// If source is already active signal with this.

const TInt KVtEngAlreadyActive = 2;

// Number of providers buffered in image sharer

const TInt KVtEngNumProvidersBuffered = 2;

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

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

// CVtEngLocalVideo::CVtEngLocalVideo

// C++ constructor can NOT contain any code, that

// might leave.

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

//

CVtEngLocalVideo::CVtEngLocalVideo(

    CVtEngMediaHandler& aObserver )

   /** priority is high to ensure that this AO gets scheduled as soon as

    * possible after signaling. If local video is requested a service, e.g.

    * source switch while its signaled but not yet scheduled, local video's

    * internal state may be compromised (signal AO => start selecting new source

    * => RunL [this would break ongoing source selection]

    */

 : CActive( EPriorityHigh ),

   iRenderingMethod( EUnspecified ),

   iObserver( aObserver ),

   iCurrentCamera( MVtEngMedia::ESecondaryCamera ),

   iLayoutChangeHandler( *this )

    {

    ResetIndices();

    __VTPRINT( DEBUG_MEDIA | DEBUG_CONSTRUCT, "LocVideo.c++")

    CActiveScheduler::Add( this );

    }

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

// CVtEngLocalVideo::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CVtEngLocalVideo::ConstructL()

    {

    __VTPRINTENTER( "LocVideo.ConstructL" )

    iAsyncCallBack = new ( ELeave ) CAsyncCallBack(

        TCallBack( CallBackFunc, this ), EPriorityStandard );

    TInt indexMobile( KErrNotFound );

    iShareImage = CVtEngShareImage::NewL( *this );

    iSourceController = CVSController::NewL( this );

    iVideoProviders =

        new ( ELeave ) CArrayFixFlat<TProviderItem>( KVtEngProviderCountMax );

    iSource = iSourceController->CreateDataSourceL( this );

    PauseVideoSending();

    TInt providers( iSourceController->ProvidersAvailable() );

    iNumSupportedCameras = providers - 1;

    ResetIndices();

    __VTPRINT2( DEBUG_MEDIA | DEBUG_CONSTRUCT, "LocVideo.providers=%d",providers)

    // Get the device specified default camera.

    TInt cameraId( iCurrentCamera );

    TInt err( SetCameraTrackingL( cameraId ) );

    if ( err == KErrNone && cameraId != EPSPreferredCameraUnknown )

        {

        // Only if valid camera.

        iCurrentCamera = MapCameraInternally( cameraId );

        err = KErrAlreadyExists;

        }

    while ( providers-- )

        {

        CVSDataProvider* provider = NULL;

        TRAP_IGNORE( provider =

            iSourceController->CreateDataProviderL( providers, this, iSource ) );

        if ( provider )

            {

            CleanupStack::PushL( provider );

            TProviderItem item;

            TVSDataProviderInfo info;

            provider->ProviderInfo( info );

            TBool destroy( ETrue );

            __VTPRINT2( DEBUG_MEDIA | DEBUG_CONSTRUCT, "LocVideo.Orient=%d",

                info.iOrientation )

            switch ( info.iOrientation )

                {

                case TCameraInfo::EOrientationInwards:

                    SetFlag( EFlagCamera1Available );

                    item.iType = KVtEngProviderCam1;

                    if ( err != KErrAlreadyExists )

                        {

                        // Set only if value not obtained from PubSub

                        iCurrentCamera = MVtEngMedia::EPrimaryCamera;

                        }

                    iProviderInfoIndexCam1 = providers;

                    __VTPRINT2( DEBUG_MEDIA | DEBUG_CONSTRUCT, "LocVideo.ConL ID C1=%d",

                        iProviderInfoIndexCam1 )

                    break;

                case TCameraInfo::EOrientationOutwards:

                    // Configures outwards camera, it is treated as camera 1

                    // if there is only one camera in the device.

                    ConfigureOutwardsCameraItem( item, providers );

                    break;

                case TCameraInfo::EOrientationMobile:

                    __VTPRINT( DEBUG_MEDIA | DEBUG_CONSTRUCT, "LocVideo.Mobile")

                    item.iType = KVtEngProviderTempImage;

                    indexMobile = providers;

                    __VTPRINT2( DEBUG_MEDIA | DEBUG_CONSTRUCT, "LocVideo.Mobile ID=%d",

                        indexMobile )

                    break;

                case TCameraInfo::EOrientationUnknown:

                    {

                    item.iType = KVtEngProviderImage;

                    item.iProvider = provider;

                    item.iProviderState = EPermanent;

                    destroy = EFalse; // don't delete still provider

                    CreateBlankProviderL( providers );

                    if ( CVtEngUtility::Settings().

                    	 IsDefaultStillImageDefined() )

                        {

                        CreateDefaultStillImageProviderL( providers );

                        }

                    iProviderInfoIndexStill = providers;

                    __VTPRINT2( DEBUG_MEDIA | DEBUG_CONSTRUCT,

                    "LocVideo.ConL ID Still=%d",iProviderInfoIndexStill )

                    }

                    break;

                default:

                    break;

                }

            iVideoProviders->AppendL( item );

            CleanupStack::Pop();

            if ( destroy )

                {

                delete provider;

                provider = NULL;

                }

            }

        }

    iObserver.SetSelectedCameraId( iCurrentCamera );

    // Check if mobile is there, and either 1 or 2 is not.

    if ( indexMobile != KErrNotFound )

        {

        TProviderItem* item = NULL;

        const TInt err = GetProviderByType( KVtEngProviderTempImage, item );

           __ASSERT_ALWAYS( err != KErrNotFound,

            Panic( EVtEngPanicInvalidInitializationState ) );

        if ( iProviderInfoIndexCam1 == KErrNotFound )

            {

            __VTPRINT( DEBUG_MEDIA | DEBUG_CONSTRUCT, "LocVideo.ConL Switch 1" )

            item->iType = KVtEngProviderCam1;

            iProviderInfoIndexCam1 = indexMobile;

            SetFlag( EFlagCamera1Available );

            }

        else

            {

            __VTPRINT( DEBUG_MEDIA | DEBUG_CONSTRUCT, "LocVideo.ConL Switch 2" )

	        DeleteProvider( KVtEngProviderCam2 );

            item->iType = KVtEngProviderCam2;

            iProviderInfoIndexCam2 = indexMobile;

            SetFlag( EFlagCamera2Available );

            }

        }

    __VTPRINTEXIT( "LocVideo.ConstructL" )

    }

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

// CVtEngLocalVideo::ConfigureOutwardsCameraItem

// Creates providers item for outwards camera type. It is treated as

// a) primary camera in single camera configurations

// b) secondary camera in two camera configurations

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

//

void CVtEngLocalVideo::ConfigureOutwardsCameraItem(

    TProviderItem& aItem,

    const TInt aCurrentIndex )

    {

    __VTPRINTENTER( "LocVideo.ConfigureOutwardsCameraItem" )

    if ( iNumSupportedCameras == 1 )

        {

        SetFlag( EFlagCamera1Available );

        aItem.iType = KVtEngProviderCam1;

        iProviderInfoIndexCam1 = aCurrentIndex;

        iCurrentCamera = MVtEngMedia::EPrimaryCamera;

        __VTPRINT2( DEBUG_MEDIA,

            "LocVideo.ConL ID C1=%d", iProviderInfoIndexCam1 )

        }

    else

        {

        SetFlag( EFlagCamera2Available );

        aItem.iType = KVtEngProviderCam2;

        iProviderInfoIndexCam2 = aCurrentIndex;

        __VTPRINT2( DEBUG_MEDIA,

            "LocVideo.ConL ID C2=%d", iProviderInfoIndexCam2 )

        }

    __VTPRINTEXITR( "LocVideo.ConfigureOutwardsCameraItem iCurrentCamera=%d",

            iCurrentCamera )

    }

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

// CVtEngLocalVideo::CallBackFunc

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

//

void CVtEngLocalVideo::CompleteOperation( const TInt aResult )

    {

    __VTPRINTENTER( "LocVideo.CompleteOperation" )

    SetResult( aResult );

    iAsyncCallBack->CallBack();

    __VTPRINTEXITR( "LocVideo.CompleteOperation %d", aResult )

    }

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

// CVtEngLocalVideo::VideoChannelOpenedL

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

//

void CVtEngLocalVideo::VideoChannelOpenedL()

    {

    __VTPRINTENTER( "LocVideo.VideoChannelOpenedL" )

    if ( iDelayedSelect.IsDelayedSelectPending() )

        {

        SelectSourceL( iDelayedSelect.DelayedSelectTarget() );

        }

    __VTPRINTEXIT( "LocVideo.VideoChannelOpenedL" )

    }

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

// CVtEngLocalVideo::CallBackFunc

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

//

TInt CVtEngLocalVideo::CallBackFunc( TAny* aPtr )

    {

    __VTPRINTENTER( "LocVideo.CallBackFunc" )

    CVtEngLocalVideo* self = reinterpret_cast< CVtEngLocalVideo* >( aPtr );

    TInt result( KErrNone );

    TRAP( result,

        self->iObserver.HandleLocalVideoOperationCompleteL(

            self->Result() ) );

    __VTPRINTEXITR( "LocVideo.CallBackFunc %d", result )

    return result;

    }

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

// CVtEngLocalVideo::Result

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

//

TInt CVtEngLocalVideo::Result() const

    {

    __VTPRINTENTER( "LocVideo.Result" )

    __VTPRINTEXITR( "LocVideo.Result %d", iResult )

    return iResult;

    }

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

// CVtEngLocalVideo::SetResult

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

//

void CVtEngLocalVideo::SetResult( const TInt aResult )

    {

    __VTPRINTENTER( "LocVideo.SetResult" )

    iResult = aResult;

    __VTPRINTEXITR( "LocVideo.SetResult %d", iResult )

    }

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

// CVtEngLocalVideo::NewL

// Two-phased constructor.

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

//

CVtEngLocalVideo* CVtEngLocalVideo::NewL(

    CVtEngMediaHandler& aObserver )

    {

    __VTPRINTENTER( "LocVid.NewL" )

    CVtEngLocalVideo* self = new( ELeave )

        CVtEngLocalVideo( aObserver );

    CleanupStack::PushL( self );

    self->ConstructL( );

    CleanupStack::Pop();

    __VTPRINTEXIT( "LocVid.NewL" )

    return self;

    }

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

// CVtEngLocalVideo::~CVtEngLocalVideo

// Destructor. Cannot leave.

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

//

CVtEngLocalVideo::~CVtEngLocalVideo()

    {

    __VTPRINTENTER( "LocVid.~" )

    // Cancel the object

    if ( iActiveProvider )

        {

        iActiveProvider->DetachFromCameraPreferences();

        }

    if ( iAsyncCallBack )

        {

        iAsyncCallBack->Cancel();

        delete iAsyncCallBack;

        }

    Cancel();

    if ( iVideoProviders )

        {

        while ( iVideoProviders->Count() )

            {

            TProviderItem& item = (*iVideoProviders)[0];

            CVSDataProvider* provider = item.iProvider;

            delete provider;

            iVideoProviders->Delete( 0 );

            }

        delete iVideoProviders;

        }

    delete iCameraListener;

    iCameraListener = NULL;

    delete iSource;

    delete iSourceController;

    DeleteAudioSource();

    delete iShareImage;

    __VTPRINTEXIT( "LocVid.~" )

    }

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

// CVtEngLocalVideo::vsProviderError

// Handles error in provider.

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

//

void CVtEngLocalVideo::vsProviderError( TInt aError )

    {

    if( aError == KErrCancel )

        {

        vsProviderReady();

        return;

        }

    __VTPRINTENTER( "LocVid.vsProviderError" )

    __VTPRINT2( DEBUG_MEDIA, "LocVideo.ProviderError=%d", aError )

    iInitializingProvider = NULL;

    if ( aError != KErrNone )

        {

        iShareImage->Error( aError );

        if ( !iLayoutChangeHandler.ProviderError( aError ) )

            {

            const TState previousState = iState;

            iState = ELocNone;

            __VTPRINT( DEBUG_MEDIA, " STATE TO NONE" )

            // If the error indicates that camera is in use

            if ( aError == KErrInUse && previousState == ELocInitializing )

            {

            // Store the error to be used later

            if( iSelectedProvider )

                {

                __VTPRINT( DEBUG_MEDIA,

                "LocVideo.ProviderError in use")

                iSelectedProvider->iErrorCode = aError;

                if ( iSelectedProvider->iType == KVtEngProviderCam1 )

                    {

                    ClearFlag( EFlagCamera1Available );

                    }

                else if ( iSelectedProvider->iType == KVtEngProviderCam2 )

                    {

                    ClearFlag( EFlagCamera2Available );

                    }

                }

            }

        // Camera has been lost

		if ( aError == KVsErrCameraNoLongerReserved )

			{

			if ( !IsActive() )

                {

                SetActive();

                TRequestStatus* status = &iStatus;

                User::RequestComplete( status, aError );

                __VTPRINT( DEBUG_MEDIA,

                	"LocVideo.ProviderError AO start" )

               	__VTPRINTEXITR(

                     "LocVid.vsProviderError err=%d", aError )

                __VTPRINT( DEBUG_MEDIA,

                	"LocVideo.ProviderError iSelectedProvider NULL" )

                if ( iSelectedProvider )

                	{

                	__VTPRINT( DEBUG_MEDIA,

                	"LocVideo.ProviderError iSelectedProvider NULL" )

                	iSelectedProvider->iInitialized = EFalse;

                	iSelectedProvider->iProviderState =

                    	(CVtEngLocalVideo::TProviderState) aError;

                	__VTPRINT( DEBUG_MEDIA,

                	"LocVideo.ProviderError iSelectedProvider NULL" )

                	}

                return;

            	}

			}

        if ( iSelectedProvider )

            {

            // Try to select the last known to function camera

            if ( iSelectedProvider->iType == KVtEngProviderCam1 ||

                 iSelectedProvider->iType == KVtEngProviderCam2 )

                {

                if ( !IsActive() )

                    {

                    SetActive();

                    TRequestStatus* status = &iStatus;

                    User::RequestComplete( status, aError );

                     __VTPRINT( DEBUG_MEDIA,

                     "LocVideo.ProviderError AO start" )

                     __VTPRINTEXITR(

                     "LocVid.vsProviderError err=%d", aError )

                     return;

                     }

                 }

                //Error code needed later

                iSelectedProvider->iInitialized = EFalse;

                iSelectedProvider->iProviderState =

                    (CVtEngLocalVideo::TProviderState) aError;

                iSelectedProvider = NULL;

                __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL,

                    " selected provider nulled" )

                }

            else if ( iActiveProvider &&

                     !IsFlag( EFlagInitializeOnly ) &&

                     previousState == ELocSwichingProvider )

                {

                iActiveProvider = iFadingProvider;

                iFadingProvider = NULL;

                }

            if ( IsFlag( EFlagSignalSourceSelection ) )

                {

                ClearFlag( EFlagSignalSourceSelection );

                TRAP_IGNORE(

                    iObserver.HandleLocalVideoOperationCompleteL( aError ) );

                }

            }

        }

    __VTPRINTEXIT( "LocVid.vsProviderError" )

    }

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

// CVtEngLocalVideo::vsProviderReady

// Provider is ready to be taken into use.

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

//

void CVtEngLocalVideo::vsProviderReady()

    {

    __VTPRINTENTER( "LocVid.vsProviderReady" )

    __VTPRINT3( DEBUG_MEDIA, "LocVideo.ProviderReady state=%d, initOnly=%d",

        iState, IsFlag( EFlagInitializeOnly ) )

    const TState prevState( iState );

    if ( iInitializingProvider )

        {

        iInitializingProvider->iInitialized = ETrue;

        // Set camera flags in order to recover

        // error situation (error occured during init)

        if ( iInitializingProvider->iType == KVtEngProviderCam1 )

        	{

			__VTPRINT( DEBUG_MEDIA, " LocVid.vsProviderReady KVtEngProviderCam1" )

        	SetFlag( EFlagCamera1Available );

        	}

        else if ( iInitializingProvider->iType == KVtEngProviderCam2 )

        	{

        	__VTPRINT( DEBUG_MEDIA, " LocVid.vsProviderReady KVtEngProviderCam2" )

        	SetFlag( EFlagCamera2Available );

        	}