/*

* 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:  Application's UI class.

*

*/

#include "musuilivesharingcontroller.h"

#include "musuicallbackservice.h"

#include "musuieventobserver.h"

#include "musuisharingobserver.h"

#include "musuisendobserver.h"

#include "musuilivesharingobserver.h"

#include "musuidialogutil.h"

#include "musenglivesession.h"

#include "musuiresourcehandler.h"

#include "musui.hrh"

#include "mussettings.h"

#include "mussettingskeys.h"

#include "muslogger.h" // debug logging

#include "musuigeneralview.h"

#include <musui.rsg>

#include <avkon.hrh>

#include <StringLoader.h>

#include <AknUtils.h>

using namespace NMusResourceApi;

using namespace MusSettingsKeys;

const TInt KMusUiIntervalToPlay = 5000000;

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

//

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

//

CMusUiLiveSharingController* CMusUiLiveSharingController::NewL(

                        MMusUiEventObserver& aEventObserver,

                        MMusUiSharingObserver& aSharingObserver,

	                    MMusUiSendObserver& aSendObserver,

                        MMusUiLiveSharingObserver& aLiveObserver,

                        const TRect& aRect )

    {

    CMusUiLiveSharingController* self =

             new( ELeave ) CMusUiLiveSharingController( aEventObserver,

                                                        aSharingObserver,

                                                        aSendObserver,

                                                        aLiveObserver );

    CleanupStack::PushL( self );

    self->ConstructL( aRect );

    CleanupStack::Pop( self );

    return self;

    }

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

//

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

//

CMusUiLiveSharingController::~CMusUiLiveSharingController()

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiLiveSharingController::~CMusUiLiveSharingController" );

    delete iSession;

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiLiveSharingController::~CMusUiLiveSharingController" );

    }

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

//

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

//

CMusUiLiveSharingController::CMusUiLiveSharingController(

                            MMusUiEventObserver& aEventObserver,    

                        	MMusUiSharingObserver& aSharingObserver,

	                        MMusUiSendObserver& aSendObserver,

	                        MMusUiLiveSharingObserver& aLiveObserver )

	: CMusUiSendController( aEventObserver, aSharingObserver, aSendObserver ),

	  iLiveObserver( aLiveObserver )

    {

    }

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

//

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

//

void CMusUiLiveSharingController::ConstructL( const TRect& aRect )

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiLiveSharingController::ConstructL" );

    CMusUiSendController::ConstructL(); // Base class construction

    iSession = CMusEngLiveSession::NewL( VideoFileNameL(),

                                         aRect,

                                         *this,

                                         *this,

                                         *this,

                                         iSipProfileId );

    iSession->SetAudioRoutingObserver( this );

    iSession->SetVolumeChangeObserver( this );

    if ( iSession->AudioRoutingCanBeChanged() )

        {

        iSession->EnableLoudspeakerL( ELoudspeakerEnabled, ETrue );

        }

    if ( iVideoCodec && iVideoCodec->Length() > 0 )

        {

        iSession->SetSupportedVideoCodecListL( *iVideoCodec );

        }

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiLiveSharingController::ConstructL" );

    }

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

//

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

//

void CMusUiLiveSharingController::PlayL()

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiLiveSharingController::PlayL" );

    CMusUiSendController::PlayL();

    iEventObserver.ShowNaviPaneIconL( 

                    (!iDiskFull) ? RecordIcon() : EMusUiNaviIconRecordNot );

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiLiveSharingController::PlayL" );

    }

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

// When orientation changed , Camera instances has to be recreated inorder

// to receive proper orientated frames.

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

//

void CMusUiLiveSharingController::RefreshCameraOrientationL()

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiLiveSharingController::RefreshCameraOrientationL" );

    if ( IsPlayingL() )

         {

         MUS_LOG( "mus: [MUSUI ]  -> Playing, pause/stop to restart camera" );

         TTimeIntervalMicroSeconds32 interval( KMusUiIntervalToPlay ); 

         PauseL();

         EnableDisplayL(false);

         EnableDisplayL(true);

         PlayL();

         } 

     else

         {

         MUS_LOG( "mus: [MUSUI ]  -> Not Playing, try display to restart camera");

         if ( IsDisplayEnabledL() )

             {

             //Disabling of display will cause disabling of viewfinder and in its 

             //turn releasing of camera, enabling of display will recreate a camera

             //with new orientation

             MUS_LOG( "mus: [MUSUI ]  -> display is enabled, disable/enable it");

             EnableDisplayL(false);

             EnableDisplayL(true);

             }

         else

             {

             MUS_LOG( "mus: [MUSUI ]  -> Not refreshing ");

             }

         }

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiLiveSharingController::RefreshCameraOrientationL" );

    }

//

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

//

void CMusUiLiveSharingController::PauseL()

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiLiveSharingController::PauseL" );

    CMusUiSendController::PauseL();

    iEventObserver.ShowNaviPaneIconL( EMusUiNaviIconPause );

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiLiveSharingController::PauseL" );

    }

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

//

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

//

void CMusUiLiveSharingController::DeleteEngineSession()

    {

    CMusUiSendController::DeleteEngineSession();

    delete iSession;

    iSession = NULL;

    }

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

//

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

//

CMusEngMceOutSession* CMusUiLiveSharingController::EngineOutSession()

    {

    return iSession; // Live session is CMusEngMceOutSession

    }

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

//

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

//

void CMusUiLiveSharingController::InviteL( const TDesC& aRecipient )

    {

    MUS_LOG_TDESC( "mus: [MUSUI ]    -> CMusUiLiveSharingController::InviteL:",

                            aRecipient );

    // Registration must not be pending in this phase

    __ASSERT_ALWAYS( !iSipRegistrationPending, 

                     iEventObserver.HandleError( KErrNotReady ) );

    delete iAddress;

    iAddress = NULL;

    iAddress = aRecipient.AllocL();

    TRAPD( err, iSession->InviteL( aRecipient ) );

    MUS_LOG( "mus: [MUSUI ]     CMusUiLiveSharingController::InviteL: After TRAPD" );

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

    // is displayed

    if ( err != KErrNone )

        {

        // Display the error message

        DismissWaitDialog();

        if ( !ExitOccured() )

            {

            MusUiDialogUtil::ShowGlobalErrorDialogL( 

                                R_MUS_LIVE_SHARING_VIEW_NOTE_INVITE_ERROR );

            }

        if ( ( ++iTriedInvitations < 2 )  && ( err == KErrArgument ) )

            {

            MUS_LOG( "mus: [MUSUI ]     CMusUiLiveSharingController::InviteL: iTriedInvitations < 2" );

            iManualAddressTyped = ETrue;

            iResourceHandler->RequestKeypadL( ETrue );

            iSendObserver.ManualAddressEntryL( *iRemoteSipAddressProposal );

            return;

            }

        else

            {

            MUS_LOG( "mus: [MUSUI ]     CMusUiLiveSharingController::InviteL: ++iTriedInvitations > 1" );

            HandleExitL();

            return;

            }

        }

    SetConnectionInitialized( ETrue );

    ShowInvitingWaitDialogL();

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiLiveSharingController::InviteL" );

    }

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

//

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

//

void CMusUiLiveSharingController::HandleSliderValueChangeL( TInt aNewLevel )

    {

    MUS_LOG1( "mus: [MUSUI ]  -> CMusUiLiveSharingController::HandleSliderValueChangeL(%d)",

              aNewLevel )

    __ASSERT_ALWAYS( !ExitOccured(), User::Leave( KErrDied ) );

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

    if ( iToolbarZoomSelected )

        {

        iSession->SetZoomL( aNewLevel );

        iLiveObserver.SetZoomL( iSession->CurrentZoomL() );

        }

    else

        {

        iSession->SetBrightnessL( aNewLevel );

        iLiveObserver.SetBrightnessL( iSession->CurrentBrightnessL() );

        }

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiLiveSharingController::HandleSliderValueChangeL" )

    }

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

//

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

//

void CMusUiLiveSharingController::OfferToolbarEventL( TInt aCommand )

    {

    MUS_LOG1( "mus: [MUSUI ]  -> CMusUiLiveSharingController::OfferToolbarEventL [%d]",

                            aCommand );

    iLiveObserver.SetZoomVisible( EFalse );

    iLiveObserver.SetBrightnessVisible( EFalse );

    switch ( aCommand )

        {

        case EMusuiCmdToolbarPauseLive:

            {

            HandleCommandL( EMusuiCmdViewPause );

            iSharingObserver.ReplaceToolbarCommand( EMusuiCmdToolbarPauseLive,

                                                    EMusuiCmdToolbarUnPauseLive,

                                                    ETrue );

            break;

            }

        case EMusuiCmdToolbarUnPauseLive:

            {

            HandleCommandL( EMusuiCmdViewContinue );

            iSharingObserver.ReplaceToolbarCommand( EMusuiCmdToolbarUnPauseLive,

                                                    EMusuiCmdToolbarPauseLive,

                                                    ETrue );

            break;

            }

        case EMusuiCmdToolbarZoom:

            {

            iToolbarZoomSelected = !iToolbarZoomSelected;

            if ( iToolbarZoomSelected )

                {

                iLiveObserver.SetZoomValues( iSession->MinZoomL(), 

                                             iSession->MaxZoomL() );

                iLiveObserver.SetZoomL( iSession->CurrentZoomL() );

                }

            iLiveObserver.SetZoomVisible( iToolbarZoomSelected );

            iSharingObserver.HighlightSelectedToolbarItem( EMusuiCmdToolbarZoom );

            break;

            }

        case EMusuiCmdToolbarBrightness:

            {

            iToolbarBrightnessSelected = !iToolbarBrightnessSelected;

            if ( iToolbarBrightnessSelected )

                {

                MUS_LOG1( "mus: [MUSUI ]     CMusUiLiveSharingController::OfferToolbarEventL: Brightness %d",

                                iSession->CurrentBrightnessL() );

                iLiveObserver.SetBrightnessValues( iSession->MinBrightnessL(),

                                                   iSession->MaxBrightnessL() );

                iLiveObserver.SetBrightnessL( iSession->CurrentBrightnessL() );

                }

            iLiveObserver.SetBrightnessVisible( iToolbarBrightnessSelected );

            iSharingObserver.HighlightSelectedToolbarItem( EMusuiCmdToolbarBrightness );

            break;

            }        

        default:    // Not live specific, let the base class handle

            {

            CMusUiEventController::OfferToolbarEventL( aCommand );

            break;

            }

        }

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiLiveSharingController::OfferToolbarEventL" );

    }

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

//

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

//

void CMusUiLiveSharingController::HandleCommandL( TInt aCommand )

    {

    MUS_LOG1( "mus: [MUSUI ]  -> CMusUiLiveSharingController::HandleCommandL [%d]",

                            aCommand );

    __ASSERT_ALWAYS( !ExitOccured(), User::Leave( KErrDied ) );

    switch ( aCommand )

        {

        case EMusuiCmdViewPause:

            {            

            PauseL();

            iEventObserver.ShowNaviPaneIconL( EMusUiNaviIconPause );

            break;

            }

        case EMusuiCmdViewContinue:

            {

            PlayL();

            break;

            }

        case EMusuiCmdViewShareVideo:

            {

            PauseL();

            // TODO: Change to video sharing

            break;

            }

        case EMusuiCmdViewShareImage:

            {

            PauseL();

            // TODO: Change to image sharing

            break;

            }

        case EMusuiCmdToolbarZoom:

            {

            iToolbarZoomSelected = ETrue;

            iToolbarBrightnessSelected = EFalse;

            iLiveObserver.SetZoomValues( iSession->MinZoomL(), 

                                         iSession->MaxZoomL() );

            iLiveObserver.SetZoomL( iSession->CurrentZoomL() );

            iLiveObserver.SetZoomVisible( iToolbarZoomSelected );

            break;

            }

        case EMusuiCmdViewMiddleSoftkeyOk:

            {

            HandleMiddleSoftkeyOkL();

            break;

            }            

        case EMusuiCmdViewZoom:

            {

            ZoomL();

            break;

            }

        case EMusuiCmdViewZoomIn:

            {

            iLiveObserver.SetZoomVisible( MUS_NO_TOOLBAR ? iZoomSelected : iToolbarZoomSelected ); 

            iSession->ZoomInL();

            iLiveObserver.SetZoomL( iSession->CurrentZoomL() );

            break;

            }

        case EMusuiCmdViewZoomOut:

            {

            iLiveObserver.SetZoomVisible( MUS_NO_TOOLBAR ? iZoomSelected : iToolbarZoomSelected ); 

            iSession->ZoomOutL();

            iLiveObserver.SetZoomL( iSession->CurrentZoomL() );

            break;

            }

        case EMusuiCmdToolbarBrightness:

            {

            iToolbarZoomSelected = EFalse;

            iToolbarBrightnessSelected = ETrue;

            iLiveObserver.SetBrightnessValues( iSession->MinBrightnessL(),

                                               iSession->MaxBrightnessL() );

            iLiveObserver.SetBrightnessL( iSession->CurrentBrightnessL() );

            iLiveObserver.SetBrightnessVisible( iToolbarBrightnessSelected );

            break;

            }

        case EMusuiCmdViewBrightness:

            {

            BrightnessL();

            break;

            }            

        case EMusuiCmdViewIncreaseBrightness:

            {

			iLiveObserver.SetBrightnessVisible( MUS_NO_TOOLBAR ? iBrightnessSelected : iToolbarBrightnessSelected ); 

            iSession->IncreaseBrightnessL();

            iLiveObserver.SetBrightnessL( iSession->CurrentBrightnessL() );

            break;

            }

        case EMusuiCmdViewDecreaseBrightness:

            {

			iLiveObserver.SetBrightnessVisible( MUS_NO_TOOLBAR ? iBrightnessSelected : iToolbarBrightnessSelected ); 

            iSession->DecreaseBrightnessL();

            iLiveObserver.SetBrightnessL( iSession->CurrentBrightnessL() );

            break;

            }            

        case EMusuiCmdRecord:

            {

            // Show toolbar hidden while showing options menu

            iEventObserver.SetToolbarVisibility( ETrue );

            if ( iDiskFull )

            	{

            	DiskFull();

            	}

            else

            	{

	            iSession->RecordL( ETrue );

	            iEventObserver.ShowNaviPaneIconL( EMusUiNaviIconRecord );

            	}

            break;

            }

        case EMusuiCmdStopRecording:

            {

            // Show toolbar hidden while showing options menu

            iEventObserver.SetToolbarVisibility( ETrue );

            iSession->RecordL( EFalse );

            iEventObserver.ShowNaviPaneIconL( EMusUiNaviIconRecordNot );

            break;

            }

        default:

            {

            // Try more general handling

            CMusUiEventController::HandleCommandL( aCommand );

            break;

            }

        }

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiLiveSharingController::HandleCommandL" );

    }