/*

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

*

*/

#include "musuisendcontroller.h"

#include "musuieventobserver.h"

#include "musuisharingobserver.h"

#include "musuisendobserver.h"

#include "musuidialogutil.h"

#include "musuicallbackservice.h"

#include "musuifileutil.h"

#include "mussettings.h"

#include "musuipropertywatch.h"

#include "mussessionproperties.h"

#include "mussettingskeys.h"

#include "musuiresourcehandler.h"

#include "muslogger.h" // debug logging

#include "musengmceoutsession.h"

#include "musenguriparser.h"

#include <musui.rsg>

#include <StringLoader.h>

#include <pathinfo.h>

#include <CDirectoryLocalizer.h>

using namespace NMusSessionApi;

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

//

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

//

CMusUiSendController::~CMusUiSendController()

    {

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

    delete iAddress;

    delete iRemoteSipAddress;

    delete iRemoteSipAddressProposal;

    TRAP_IGNORE( DeleteFileL() );  

    delete iVideoFileName;

    delete iLocalizer;

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

    }

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

//

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

//

CMusEngMceSession* CMusUiSendController::EngineSession()

    {

    return EngineOutSession(); // Engine out session is CMusEngMceSession

    }

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

//

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

//

void CMusUiSendController::DeleteEngineSession()

    {

    // Cancel invite

    if ( EngineOutSession() && !ConnectionEstablished() )

        {

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

                            Canceling inviting..." );

        TRAP_IGNORE( EngineOutSession()->CancelInviteL() );

        }

    }     

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

//

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

//

void CMusUiSendController::HandlePropertyError( const TInt aReason )

    {

    MUS_LOG1( "mus: [MUSUI ]     -> CMusUiEventController::HandleError [%d]",

                            aReason );

    TRAP_IGNORE( DeleteVideoL() );

    CMusUiEventController::HandlePropertyError( aReason ); // For the base class

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiEventController::HandleError" );

    }

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

//

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

//

void CMusUiSendController::HandleAsyncEventL( TMusUiAsyncEvent aEventId )

    {

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

    switch ( aEventId )

        {

        case EMusUiAsyncInviteCancel:

            {

            MUS_LOG( "mus: [MUSUI ]     CMusUiSendController::\

                     HandleAsyncEventL: EMusUiAsyncInviteCancel" );

            HandleExitL();

            break;

            }

        case EMusUiAsyncManualAddressEntry:

            {

            iResourceHandler->RequestKeypadL( ETrue ); // Exits on fail                    

            iSendObserver.ManualAddressEntryL( *iRemoteSipAddressProposal );

            break;

            }

        case EMusUiAsyncStartInvitation:

            {

            MUS_LOG( "mus: [MUSUI ]     CMusUiSendController::\

                     HandleAsyncEventL: EMusUiAsyncStartInvitation" );

            InviteL();	            

            break;

            }

        default:

            {

            // Not send specific, let the base class handle

            CMusUiEventController::HandleAsyncEventL( aEventId );

            }

        }

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

    }

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

//

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

//

const TDesC& CMusUiSendController::TypedAddress() const

    {

    return *iAddress;

    }

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

//

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

//

TBool CMusUiSendController::ManualAddressTyped() const

    {

    return iManualAddressTyped;

    }

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

//

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

//

void CMusUiSendController::StartInvitationL()

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiSendController::StartInvitationL" );

    iCallbackService->AsyncEventL( EMusUiAsyncStartInvitation );

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiSendController::StartInvitationL" );

    }

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

//

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

//

void CMusUiSendController::InviteL()

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiSendController::InviteL" );

    if ( !iSipRegistrationPending )

        {

        TRAPD( error, 

               iRemoteSipAddress = CMusUiPropertyWatch::ReadDescPropertyL(

                                                    KRemoteSipAddress ) );

        if ( error != KErrNone )

            {

            iRemoteSipAddress = KNullDesC().AllocL();

            }

        TRAP( error, iRemoteSipAddressProposal =

                                CMusUiPropertyWatch::ReadDescPropertyL(

                                                    KRemoteSipAddressProposal ) );

        if ( error != KErrNone )

            {

            iRemoteSipAddressProposal = KNullDesC().AllocL();

            }

        if ( iRemoteSipAddress->Length() > 0 )

            {

            if ( iRemoteSipAddress->Find( KMusCommaSymbol ) == KErrNotFound )

                {

                InviteL( *iRemoteSipAddress );

                }

            else

                {

                // Split the addresses using KMusCommaSymbol as a separator

                CDesCArray* addressArray =

                            new ( ELeave ) CDesCArrayFlat(

                                                    KMusSipAddressesMaxAmount );

                SplitL( *iRemoteSipAddress, KMusCommaSymbol, addressArray );

                // Show List Query Dialog

                TBuf<KMusSipAddressMaxLength> selectedAddress;

                if ( MusUiDialogUtil::SelectAddressDialogL( addressArray, 

                                                            selectedAddress ) )

                    {

                    // Invite with the chosen address                    

                    InviteL( selectedAddress );

                    }

                else

                    {

                    HandleExitL();

                    }

                }

            }

        else

            {

            iResourceHandler->RequestKeypadL( ETrue ); // Exits on failure

            iManualAddressTyped = ETrue;

            iSendObserver.ManualAddressEntryL( *iRemoteSipAddressProposal );

            }

        }

    else

        {

        // Show waiting dialog

        delete iDialogPrompt;

        iDialogPrompt = NULL;

        iDialogPrompt = StringLoader::LoadL(

                                R_MUS_REGISTRATION_PENDING_WAIT_NOTE_TXT );

        if ( !iSharingObserver.ShowWaitDialogL( 

                                    *iDialogPrompt, 

                                    KMusInviteExpireTimeout, //Reuse 1 min timer

                                    R_MUS_LIVE_SHARING_VIEW_NOTE_NO_REG ) )

            {

            iEventObserver.HandleExit();

            }

        }

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

    }    

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

//

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

//

void CMusUiSendController::CancelInvitationL()

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiSendController::CancelInvitationL" );

    if ( EngineOutSession() && !ConnectionEstablished() )

        {

        TRAP_IGNORE( EngineOutSession()->CancelInviteL() );

        }

    HandleExitL();

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiSendController::CancelInvitationL" );

    }

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

//

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

//

void CMusUiSendController::HandleForegroundEventL( TBool aForeground )

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiSendController::HandleForegroundEventL" );

    CMusUiEventController::HandleForegroundEventL( aForeground );

    if ( ConnectionEstablished() &&  !ExitOccured() )

        {

        if ( aForeground )

            { 

            if ( iContinuePlayingWhenForeground )

                {

                MUS_LOG( "mus: [MUSUI ]     Resume playing" );

                PlayL();

                }

            }

        else

            {

            MUS_LOG( "mus: [MUSUI ]     Pause playing" );

            if ( EngineOutSession() )

                {

                iContinuePlayingWhenForeground = IsPlayingL(); 

                }

            PauseL();

            }

        }

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiSendController::HandleForegroundEventL" );

    }

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

//

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

//

void CMusUiSendController::PlayL()

    {

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

    if ( EngineOutSession() )

        {

        EngineOutSession()->PlayL();

        }

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

    }

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

//

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

//

void CMusUiSendController::PauseL()

    {

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

    if ( EngineOutSession() )

        {

        EngineOutSession()->PauseL();

        }

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

    }

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

//

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

//

TBool CMusUiSendController::IsPlayingL()

    {

    TBool isPlaying( EFalse );

    if ( EngineOutSession() )

        {

        isPlaying = EngineOutSession()->IsPlayingL();

        }

    return isPlaying;

    }

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

//

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

//

void CMusUiSendController::SessionEstablished()

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiSendController::SessionEstablished" );

    // Common handling first

    CMusUiEventController::SessionEstablished();

    iConnectionEstablished = ETrue;

    DismissWaitDialog();

    if ( iForeground )

        {

        MUS_LOG( "mus: [MUSUI ]     Enable display and start playing" );

        TRAP_IGNORE( PlayL(); 

                     EnableDisplayL( ETrue ); )

        iEventObserver.SetToolbarVisibility( ETrue );

        }

    else

        {

        MUS_LOG( "mus: [MUSUI ]     In background, don't start playing yet" );

        iContinuePlayingWhenForeground = ETrue;

        }

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiSendController::SessionEstablished" );

    }

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

//

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

//

void CMusUiSendController::SessionRejected()

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiSendController::SessionRejected" );

    DismissWaitDialog();

    TRAP_IGNORE( iCallbackService->AsyncEventL( EMusUiAsyncHandleExit ) );

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiSendController::SessionRejected" );

    }

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

//

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

//

void CMusUiSendController::SessionBadRequest()

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiSendController::SessionBadRequest" );

    DismissWaitDialog();

    TRAP_IGNORE( iCallbackService->AsyncEventL( EMusUiAsyncHandleExit ) );

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiSendController::SessionBadRequest" );

    }

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

//

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

//

void CMusUiSendController::SessionUnauthorized()

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiSendController::SessionUnauthorized" );

    DismissWaitDialog();

    TRAP_IGNORE( iCallbackService->AsyncEventL( EMusUiAsyncHandleExit ) );

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiSendController::SessionUnauthorized" );

    }

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

//

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

//

void CMusUiSendController::SessionPaymentRequired()

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiSendController::SessionPaymentRequired" );

    DismissWaitDialog();

    TRAP_IGNORE( iCallbackService->AsyncEventL( EMusUiAsyncHandleExit ) );

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiSendController::SessionPaymentRequired" );

    }

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

//

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

//

void CMusUiSendController::SessionRecipientNotFound()

    {

    MUS_LOG1( "mus: [MUSUI ]     -> CMusUiSendController::SessionRecipientNotFound [%d]",

                            iTriedInvitations );

    DismissWaitDialog();

    if ( ExitOccured() )

        {

        return;

        }

    if ( ++iTriedInvitations > 1 )

        {

        TRAP_IGNORE( MusUiDialogUtil::ShowInformationDialogL(

                                R_MUS_LIVE_SHARING_VIEW_NOTE_WRONG_ADDRESS ) );

        TRAP_IGNORE( iCallbackService->AsyncEventL( EMusUiAsyncInviteCancel ) );

        }

    else

        {

        TRAP_IGNORE( MusUiDialogUtil::ShowInformationDialogL(

                                R_MUS_LIVE_SHARING_VIEW_NOTE_WRONG_ADDRESS ) );

        iManualAddressTyped = ETrue;

        TRAP_IGNORE(

            iCallbackService->AsyncEventL( EMusUiAsyncManualAddressEntry ) );

        }

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiSendController::SessionRecipientNotFound" );

    }

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

//

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

//

void CMusUiSendController::SessionProxyAuthenticationRequired()

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiSendController::SessionProxyAuthenticationRequired" );

    DismissWaitDialog();

    TRAP_IGNORE( iCallbackService->AsyncEventL( EMusUiAsyncHandleExit ) );