/*

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

#include "musuicallbackservice.h"

#include "musuieventobserver.h"

#include "musuisharingobserver.h"

#include "musuisendobserver.h"

#include "musuiclipsharingobserver.h"

#include "musuidialogutil.h"

#include "musengclipsession.h"

#include "mussettings.h"

#include "mussettingskeys.h"

#include "musuiresourcehandler.h"

#include "musui.hrh"

#include "muslogger.h" // debug logging

#include "musuiactivetimer.h"

#include "musuigeneralview.h"

#include <musui.rsg>

#include <StringLoader.h>

#include <AknUtils.h>

#include <badesca.h>

#include <avkon.hrh>

// CONSTANTS

const TInt KMusTimeToCloseAfterClipEndedStandard  = 60 * 1000000; // 60 seconds

const TInt KMusTimeToCloseAfterClipEndedOpVariant =  1 * 1000000; //  1 second

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

//

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

//

CMusUiClipSharingController* CMusUiClipSharingController::NewL(

                                MMusUiEventObserver& aEventObserver,

                                MMusUiSharingObserver& aSharingObserver,

        	                    MMusUiSendObserver& aSendObserver,

                                MMusUiClipSharingObserver& aClipObserver,

                                const TRect& aRect )

    {

    CMusUiClipSharingController* self =

            new( ELeave ) CMusUiClipSharingController( aEventObserver,

                                                       aSharingObserver,

                                                       aSendObserver,

                                                       aClipObserver );

    CleanupStack::PushL( self );

    self->ConstructL( aRect );

    CleanupStack::Pop( self );

    return self;

    }

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

//

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

//

CMusUiClipSharingController::~CMusUiClipSharingController()

    {

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

    delete iCloseTimer;

    DeleteEngineSession();

    delete iFileName;

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

    }

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

//

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

//

CMusUiClipSharingController::CMusUiClipSharingController(

                                MMusUiEventObserver& aEventObserver,

                                MMusUiSharingObserver& aSharingObserver,

                                MMusUiSendObserver& aSendObserver,

                                MMusUiClipSharingObserver& aClipObserver )

    :CMusUiSendController( aEventObserver, aSharingObserver, aSendObserver ),

    iClipObserver( aClipObserver )

    {

    }

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

//

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

//

void CMusUiClipSharingController::ConstructL( const TRect& aRect )

    {

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

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

    iRect = aRect;  

    iSession = CMusEngClipSession::NewL( iRect,

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

        }

   	iCallbackService->AsyncEventL( EMusUiAsyncStartMediaGallery );

   	iCloseTimer = CMusUiActiveTimer::NewL( this );

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

    }

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

//

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

//

void CMusUiClipSharingController::HandleAsyncEventL( TMusUiAsyncEvent aEventId )

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiClipSharingController::HandleAsyncEventL" );

    switch ( aEventId )

        {

        case EMusUiAsyncStartMediaGallery:

            {

            iTranscode = EFalse;

            iTranscodingGoing = EFalse;

            if ( !iSession )

                {

                iSession = CMusEngClipSession::NewL( iRect, 

                                                     *this, 

                                                     *this, 

                                                     *this, 

                                                     iSipProfileId );

                iSession->SetAudioRoutingObserver( this );

                }

            // Do fetching guarded. If registration completes during fetching,

            // there is no need to do anything.

            iFileFetchingOngoing = ETrue;

            iClipObserver.RunFetchDialogL();

            iFileFetchingOngoing = EFalse;

            TRAPD( error,

                   iSession->SetClipL( *iFileName ) )

            MUS_LOG_TDESC( "mus: [MUSUI ]     File name: ",

                           iFileName->Des() )

            if ( error == KErrNone)

                {

				if ( iSession->AudioRoutingCanBeChanged() )

                    {

                    iSession->EnableLoudspeakerL( ELoudspeakerEnabled, ETrue );

                    }

                iClipEnded = EFalse;                   

                StartInvitationL();	

                }

            else if ( error == KErrPermissionDenied )

                {

                MusUiDialogUtil::ShowInformationDialogL( 

                                        R_MUS_VIEW_DRM_INFO_SEND_FORBID );

                DeleteEngineSession();

                delete iFileName;

                iFileName = NULL;

 				iSession = CMusEngClipSession::NewL( iRect,

                                                     *this,

                                                     *this,

                                                     *this,

                                                     iSipProfileId );

                iSession->SetAudioRoutingObserver( this );

                if ( iSession->AudioRoutingCanBeChanged() )

                    {

                    iSession->EnableLoudspeakerL( ELoudspeakerEnabled, ETrue );

                    }

                iCallbackService->AsyncEventL( EMusUiAsyncStartMediaGallery );

                }

            else

                {

                HandleExitL();

                }

            break;

            }

        case EMusUiAsyncStartTranscoding:

            {

            // Parse Target Filename for the transcoding result

            // and start transcoding:

            //iSession->TranscodeL( VideoFileNameL() );

            // Show progress dialog:

            //iObserver->ShowTranscodingProgressDialogL();

            iTranscodingGoing = ETrue;

            break;

            }  

        default:

            {

            // Not clip specific, let the base class handle

            CMusUiSendController::HandleAsyncEventL( aEventId );

            }

        }

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiClipSharingController::HandleAsyncEventL" );

    }

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

//

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

//

void CMusUiClipSharingController::DeleteEngineSession()

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiClipSharingController::DeleteEngineSession" );

    CMusUiSendController::DeleteEngineSession();

    // Cancel transcoding

    if ( iSession && iTranscodingGoing )

        {

        MUS_LOG( "mus: [MUSUI ]     CMusUiClipSharingController::DeleteEngineSession:\

                            Canceling transcoding..." );

        DismissWaitDialog();

        TRAP_IGNORE( MusUiDialogUtil::ShowGlobalErrorDialogL( 

                                R_MUS_VIEW_NOTE_UNABLE_TO_CONVERT );

                     iSession->CancelTranscodeL() );

        }

    delete iSession;

    iSession = NULL;

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiClipSharingController::DeleteEngineSession" );

	}

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

//

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

//

CMusEngMceOutSession* CMusUiClipSharingController::EngineOutSession()

    {

    return iSession; // Clip session is CMusEngMceOutSession

    }

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

// Handles status changes specific to sending sharing types.

// Calls base class version for status changes that are not sending specific. 

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

//

void CMusUiClipSharingController::HandleChangedStatusL(

                        TMusAvailabilityStatus aStatus )

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiClipSharingController::HandleChangedStatusL" )

    switch( aStatus )

        {

        case EMultimediaSharingAvailable:

            {

            MUS_LOG( "mus: [MUSUI ]     EMultimediaSharingAvailable" )

            if ( iSipRegistrationPending )

                {

                iSipRegistrationPending = EFalse;

                // If fecth dialog is still open, there is no need to do anything

                if ( !iFileFetchingOngoing )

                	{

                	iSipRegistrationPending = EFalse;

                    // Set callback service, Call StartInvitationL when wait dialog dismissed

                	TRAPD( err, iSharingObserver.SetWaitDialogCallbackL( 

                	            &iWaitDialogCallback ) );

                    // Dismiss pending wait note

            	    iSharingObserver.DismissWaitDialogL();

            	    if ( err == KErrNotReady )

            	        {

            	        StartInvitationL();	

            	        }

                	}

                }

            break;

            }   

        default:

            {

            // Not clip specific, let the base class handle

            CMusUiSendController::HandleChangedStatusL( aStatus );

            break;

            }

        }

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiClipSharingController::HandleChangedStatusL" )

    }

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

//

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

//

void CMusUiClipSharingController::InviteL( const TDesC& aRecipient )

    {

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

                            aRecipient );

    // Registration must not be pending in this phase

    __ASSERT_ALWAYS( !iSipRegistrationPending, 

                     iEventObserver.HandleError( KErrNotReady ) );

    delete iAddress;

    iAddress = NULL;

    iAddress = aRecipient.AllocL();

    TBool inviteProceeding = DoInviteL();

    if ( !inviteProceeding )

        {

        MUS_LOG( "mus: [MUSUI ]  <- CMusUiClipSharingController::InviteL, invite failed" );

        return;

        }      

    if( iTranscode )

        {

        MUS_LOG( "mus: [MUSUI ]     Starting transcode..." );

        iTranscode = EFalse;

        // Start transcoding

        iTranscodingGoing = ETrue;

        SetFileNameL( VideoFileNameL() );

        TRAPD( err, iSession->TranscodeL( *iFileName ) );

        if ( err != KErrNone )

            {

            MUS_LOG1( "mus: [MUSUI ]     Transcoding failed: %d", err );

            iTranscodingGoing = EFalse;

            if ( iTranscodeDueUnknownRemoteCapas )

                {

                MUS_LOG( "mus: [MUSUI ]     Retry invite without transcoding" );

                // Still retry the clip without transcoding as other end might support current codec.

                iVideoToBeSaved = EFalse;

                inviteProceeding = DoInviteL();

                }

            else if ( err == KErrNotFound )  // No Video Editor Engine

                {

                MusUiDialogUtil::ShowGlobalErrorDialogL(

                    R_MUS_LIVE_SHARING_VIEW_NOTE_TRANSCODING_NOT_SUPPORTED );

                DeleteEngineSession();

                iVideoToBeSaved = EFalse;

                HandleExitL();

                inviteProceeding = EFalse;

                }

            else

                {

                // Unable to convert clip, if transc. leaves.

                // After note return back to the media gallery.

                TranscodingFailed();

                inviteProceeding = EFalse;

                }

            }

        else

            {

            // Show progress dialog:

            iClipObserver.ShowTranscodingProgressDialogL();

            inviteProceeding = EFalse;

            }

        }

    if ( inviteProceeding )

        {

        SetConnectionInitialized( ETrue );

        ShowInvitingWaitDialogL();

        }

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

    }

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

//

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

//

TBool CMusUiClipSharingController::DoInviteL()

    {

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

    TRAPD( err, iSession->InviteL( *iAddress ) );

    MUS_LOG( "mus: [MUSUI ]     CMusUiClipSharingController::DoInviteL: After TRAPD" );

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

    // is displayed

    if ( err != KErrNone )

        {

        DismissWaitDialog();

        MusUiDialogUtil::ShowGlobalErrorDialogL(

                          R_MUS_LIVE_SHARING_VIEW_NOTE_INVITE_ERROR );

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

            {

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

            iManualAddressTyped = ETrue;

            iResourceHandler->RequestKeypadL( ETrue );

            // If the address has to be queried again...:

            iTranscode = EFalse;

            MUS_LOG_TDESC( "mus: [MUSUI ]     CMusUiClipSharingController::DoInviteL: ",

                     iFileName->Des() )

            iSendObserver.ManualAddressEntryL( *iRemoteSipAddressProposal );

            }

        else

            {

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

            DeleteEngineSession();

            HandleExitL();

            }

        }

    return ( err == KErrNone );

    }

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

//

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

//

void CMusUiClipSharingController::HandleSliderValueChangeL( TInt aNewLevel )

    {

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

              aNewLevel )

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

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

    iSession->SetPositionL( TTimeIntervalSeconds( aNewLevel ) );

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

    }

void CMusUiClipSharingController::OfferToolbarEventL( TInt aCommand )

    {

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

                            aCommand );

    switch ( aCommand )

        {

        case EMusuiCmdToolbarPause:

            {

            HandleCommandL( EMusuiCmdViewPause );

            iSharingObserver.ReplaceToolbarCommand( EMusuiCmdToolbarPause,

                                                    EMusuiCmdToolbarUnPause,

                                                    ETrue );

            break;

            }

        case EMusuiCmdToolbarUnPause:

            {

            HandleCommandL( EMusuiCmdViewContinue );

            iSharingObserver.ReplaceToolbarCommand( EMusuiCmdToolbarUnPause,

                                                    EMusuiCmdToolbarPause,

                                                    ETrue );

            break;

            }

        case EMusuiCmdToolbarFFRev:

            {

            iToolbarFFRevSelected = !iToolbarFFRevSelected; 

            iClipObserver.SetDurationValue( iSession->DurationL().Int() );

            if ( iToolbarFFRevSelected )

                {

                iWasPlayingBeforeWinding = iSession->IsPlayingL();

                PauseL();

                }

            else

                {

                StopWindingL();

                if ( iWasPlayingBeforeWinding )

                    {

                    PlayL();

                    }

                }

//            iClipObserver.SetDurationVisible();

            iSharingObserver.HighlightSelectedToolbarItem( EMusuiCmdToolbarFFRev );

            break;

            }

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

            {

            CMusUiEventController::OfferToolbarEventL( aCommand );

            break;

            }    

        }

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

    }

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

//

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

//

void CMusUiClipSharingController::HandleCommandL(TInt aCommand)

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiClipSharingController::HandleCommandL" );

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

    switch ( aCommand )

        {

        case EMusuiCmdViewPause:

            {

            PauseL();

            iEventObserver.ShowNaviPaneIconL( EMusUiNaviIconPause );