/*

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

#include "musuilivesharingview.h"

#include "musuiclipsharingview.h"

#include "musuireceiveview.h"

#include "musuistatuspanehandler.h"

#include "musuistartcontroller.h"

#include "musuiactivequerydialog.h"

#include "musuidefinitions.h"

#include "mussettings.h"

#include "mussettingskeys.h"

#include "musmanagercommon.h"

#include "musuiresourcehandler.h"

#include "musui.hrh"

#include "musuid.hrh"

#include "muslogger.h" // debug logging

#include <musui.rsg>

#include <musui.mbg>

#include <csxhelp/msh.hlp.hrh>

#include <avkon.hrh>

#include <AknsUtils.h>

#include <remconcoreapitarget.h>

#include <remconinterfaceselector.h>

#include <akntoolbar.h>

#include <AknVolumePopup.h>

using namespace MusSettingsKeys;

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

// Symbian second-phase constructor.

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

//

void CMusUiAppUi::ConstructL()

    {

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

    BaseConstructL( EAknEnableSkin | EAppOrientationAutomatic | EAknEnableMSK 

    		      | EAknSingleClickCompatible );

    iResourceHandler = CMusUiResourceHandler::NewL( *this );

    MultimediaSharing::TMusUseCase usecase = MusUiStartController::ReadUseCaseL();

    iResourceHandler->CheckInitialOrientationL(usecase);

    iForeground = ETrue;

    // View for Live Sharing:

    CMusUiLiveSharingView* liveSharingView =

                            new ( ELeave ) CMusUiLiveSharingView;

    CleanupStack::PushL( liveSharingView );

    liveSharingView->ConstructL();

    AddViewL( liveSharingView );      // transfer ownership to CAknViewAppUi

    CleanupStack::Pop( liveSharingView );

    // View for Clip Sharing:

    CMusUiClipSharingView* clipSharingView =

                            new ( ELeave ) CMusUiClipSharingView;

    CleanupStack::PushL( clipSharingView );

    clipSharingView->ConstructL();

    AddViewL( clipSharingView );      // transfer ownership to CAknViewAppUi

    CleanupStack::Pop( clipSharingView );

    // View for Receiving:

    CMusUiReceiveView* receiveView =  new ( ELeave ) CMusUiReceiveView;

    CleanupStack::PushL( receiveView );

    receiveView->ConstructL();

    AddViewL( receiveView );      // transfer ownership to CAknViewAppUi

    CleanupStack::Pop( receiveView );

    FindWindowGroupIdentifiersL();

    iStatusPaneHandler = CMusUiStatusPaneHandler::NewL( *iEikonEnv );

    // The application icon:

    iStatusPaneHandler->SetStatusPaneIconsL(

                            EMbmMusuiQgn_menu_mus_app_cxt,

                            EMbmMusuiQgn_menu_mus_app_cxt_mask );

    iStatusPaneHandler->GetVolumePopup()->SetObserver(this);

    AknsUtils::InitSkinSupportL();

    AknsUtils::SetAvkonSkinEnabledL( ETrue );

    // Check use case and set default view

    switch ( usecase )

        {

        case MultimediaSharing::EMusLiveVideo:

            ActivateLocalViewL( liveSharingView->Id() );

            break;

        case MultimediaSharing::EMusClipVideo:

            ActivateLocalViewL( clipSharingView->Id() );

            break;

        case MultimediaSharing::EMusReceive:

            ActivateLocalViewL( receiveView->Id() );

            break;

        default:

            User::Leave( KErrNotSupported );

            break;

        }

    iInterfaceSelector = CRemConInterfaceSelector::NewL();

    iCoreTarget = CRemConCoreApiTarget::NewL(*iInterfaceSelector, *this);

    iInterfaceSelector->OpenTargetL();

    // check if operator specific functionality is needed  

    iOperatorSpecificFunctionality = 

        ( MultimediaSharingSettings::OperatorVariantSettingL() == 

                                                    EOperatorSpecific );

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

    }

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

// Destructor.

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

//

CMusUiAppUi::~CMusUiAppUi()

    {

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

    delete iResourceHandler;

    delete iConfirmationQuery;

    delete iStatusPaneHandler;

    delete iInterfaceSelector;

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

    }

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

// Fetches a handle to status pane handler

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

//

CMusUiStatusPaneHandler* CMusUiAppUi::MusStatusPane()

    {

    return iStatusPaneHandler;

    }

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

//

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

//

TBool CMusUiAppUi::ExitValue()

    {

    return iExit;

    }

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

//

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

//

void CMusUiAppUi::HandleWsEventL( const TWsEvent& aEvent, CCoeControl* aDestination )

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiAppUi::HandleWsEventL" );

    const TInt type = aEvent.Type();

    // Avoiding unknown failures

    if( !iView )

        {

        MUS_LOG( "mus: [MUSUI ]  <- CMusUiAppUi::HandleWsEventL, view is NULL" );

        return;

        }

    if( type == EEventKeyUp )

        {

        static_cast<CMusUiGeneralView*>

                ( iView )->HandleKeyUpEvent( iLastKeyCode );

        }

    if ( ( type == EEventKey ) && iView->Toolbar()->IsShown() && !MUS_NO_TOOLBAR )

        {

        const TKeyEvent* keyEvent = aEvent.Key();

        iLastKeyCode = keyEvent->iCode;        

        MUS_LOG1( "mus: [MUSUI ]     CMusUiAppUi::HandleWsEventL iCode: %d", 

                                keyEvent->iCode );

        CMusUiGeneralView* activatedView = 

                                    static_cast<CMusUiGeneralView*>( iView );

        activatedView->HandleToolbarCommandL( keyEvent->iCode );

        }

    if ( type == KAknFullOrPartialForegroundLost ||

         type == EEventFocusLost ||

         type == KAknFullOrPartialForegroundGained ||

         type == EEventFocusGained )

        {

        DoHandleForegroundEventL( type );

        }

    // All events are sent to base class.

    CAknAppUi::HandleWsEventL( aEvent, aDestination );

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiAppUi::HandleWsEventL" );

    }

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

//

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

//

void CMusUiAppUi::HandleForegroundEventL( TBool aForeground )

    {

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

    CAknViewAppUi::HandleForegroundEventL( aForeground );

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

    }

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

//

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

//

void CMusUiAppUi::MrccatoCommand( TRemConCoreApiOperationId aOperationId, 

                                  TRemConCoreApiButtonAction aButtonAct )

    {

    MUS_LOG2( "mus: [MUSUI ]  -> CMusUiAppUi::MrccatoCommand: %d, %d", 

              aOperationId,

              aButtonAct );

    switch ( aOperationId )

        {

        case ERemConCoreApiVolumeUp:  //  Volume Up

            {

            switch ( aButtonAct )

                {

                case ERemConCoreApiButtonClick:

                    {

                    // volume up clicked

                    CMusUiGeneralView* activatedView = 

                                    static_cast<CMusUiGeneralView*>( iView );

                                    if( MUS_NO_TOOLBAR )

                                        {

                                        TRAP_IGNORE( activatedView->HandleCommandL( 

                                                EMusuiCmdViewVolumeUp ) )                                        

                                        }

                                    else

                                        {

                                        TRAP_IGNORE( activatedView->HandleToolbarCommandL( 

                                                EMusuiCmdViewVolumeUp ) )

                                        }

                    break;

                    }

                default:

                    // Never hits this

                    break;

                }

                break;

            }

        case ERemConCoreApiVolumeDown:  //  Volume Down

            {

            switch ( aButtonAct )

                {

                case ERemConCoreApiButtonClick:

                    {

                    // volume down clicked

                    CMusUiGeneralView* activatedView = 

                                    static_cast<CMusUiGeneralView*>( iView );

                                    if( MUS_NO_TOOLBAR )

                                        {

                                        TRAP_IGNORE( activatedView->HandleCommandL( 

                                                    EMusuiCmdViewVolumeDown ) )

                                        }

                                    else

                                        {

                                        TRAP_IGNORE( activatedView->HandleToolbarCommandL( 

                                                    EMusuiCmdViewVolumeDown ) )                                        

                                        }

                    break;

                    }

                default:

                    // Never hits this

                    break;

                }

                break;

            }

        }

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiAppUi::MrccatoCommand" );

    }

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

//

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

//

void CMusUiAppUi::QueryAcceptedL( TBool aAccepted )

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiAppUi::QueryAccepted" );

    CMusUiGeneralView* activatedView = static_cast<CMusUiGeneralView*>( iView );

    // TODO: If next call leaves, it causes error handling to be done with

    // previously deleted query object. This leads to crash.

    activatedView->AsyncQueryDialogAcceptedL( aAccepted );

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiAppUi::QueryAccepted" );

    }

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

// 

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

//

TInt CMusUiAppUi::HandleQueryError( TInt aError )

    {

    HandleError( aError ); // Forward to general error handler

    return KErrNone;

    }

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

//

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

//

void CMusUiAppUi::ActivateLocalMusViewL( TUid aViewId )

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiAppUi::ActivateLocalMusViewL" );

    ActivateLocalViewL( aViewId );

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiAppUi::ActivateLocalMusViewL" );

    }

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

//

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

//

void CMusUiAppUi::ActivateLocalMusViewL( TUid aViewId,

                                         TUid aCustomMessageId,

                                         const TDesC8& aCustomMessage )

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiAppUi::ActivateLocalMusViewL" );

    ActivateLocalViewL( aViewId, aCustomMessageId, aCustomMessage );

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiAppUi::ActivateLocalMusViewL" );

    }

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

//

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

//

void CMusUiAppUi::ShowAsyncConfirmationQueryDialogL( const TDesC& aPrompt )

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiAppUi::ShowAsyncConfirmationQueryDialogL" );

    if ( !iConfirmationQuery )

        {

        iConfirmationQuery = CMusUiActiveQueryDialog::NewL( *this );

        }

    iConfirmationQuery->ShowL( aPrompt );

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiAppUi::ShowAsyncConfirmationQueryDialogL" );

    }

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

//

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

//

void CMusUiAppUi::SetToolbarVisibility( TBool aVisible )

    {

    CMusUiGeneralView* activatedView = static_cast<CMusUiGeneralView*>( iView );

    if ( activatedView )

        {

        activatedView->SetToolbarVisibility( aVisible );

        }

    }

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

//

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

//

void CMusUiAppUi::ShowNaviPaneIconL( TMusUiNaviMediaDecorator aIcon )

    {

    MusStatusPane()->ShowNaviPaneIconL( aIcon );

    }

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

//

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

//

CEikonEnv* CMusUiAppUi::EikonEnv( ) const

    {

    return iEikonEnv;

    }

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

//

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

//

void CMusUiAppUi::TerminateCall()

    {

    // TODO: Remove hard-coded values!

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiAppUi::TerminateCall" );

    RWsSession sess = iEikonEnv->WsSession();

    TApaTaskList taskList(sess);

    TApaTask phoneTask = taskList.FindApp(TUid::Uid(0x100058B3));

    MUS_LOG( "mus: [MUSUI ]     phoneTask" );

    TInt id = 0;

    if (phoneTask.Exists())

        id = phoneTask.WgId();

    MUS_LOG1( "PhoneTask ID: %d",id );    

    TWsEvent event;

    MUS_LOG( "mus: [MUSUI ]     CMusUiAppUi::TerminateCall: 1" );

    MUS_LOG( "mus: [MUSUI ]     CMusUiAppUi::EEventKeyDown" );

    event.SetType( EEventKeyDown );

    event.SetTimeNow();

    event.Key()->iCode = 0;

    event.Key()->iModifiers = EModifierNumLock;

    event.Key()->iRepeats = 0;

    event.Key()->iScanCode = EStdKeyNo;

    sess.SendEventToWindowGroup( id, event ); 

    MUS_LOG( "mus: [MUSUI ]     CMusUiAppUi::TerminateCall: 2" );

    MUS_LOG( "mus: [MUSUI ]     CMusUiAppUi::EEventKey" );

    event.SetType( EEventKey );

    event.SetTimeNow();

    event.Key()->iCode = EKeyNo;

    event.Key()->iModifiers = 32769;

    event.Key()->iRepeats = 0;

    event.Key()->iScanCode = EStdKeyNo;

    sess.SendEventToWindowGroup( id, event ); 

   	MUS_LOG( "mus: [MUSUI ]     CMusUiAppUi::TerminateCall: 3" );

    MUS_LOG( "mus: [MUSUI ]     CMusUiAppUi::EEventKeyUp" );

    event.SetType( EEventKeyUp );

    event.SetTimeNow();

    event.Key()->iCode = 0;

    event.Key()->iModifiers = 32769;

    event.Key()->iRepeats = 0;

    event.Key()->iScanCode = EStdKeyNo;

    sess.SendEventToWindowGroup( id, event );

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiAppUi::TerminateCall" );

    }

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

// Return current app orientation.

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

//

CAknAppUiBase::TAppUiOrientation CMusUiAppUi::AppOrientation() const

    {

    return ( ApplicationRect().Width() > ApplicationRect().Height() ) ?

            CAknAppUiBase::EAppUiOrientationLandscape :

            CAknAppUiBase::EAppUiOrientationPortrait;

    }

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

// Switch the active view's orientation, if it's in the foreground.

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

//

void CMusUiAppUi::SwitchOrientationL( TAppUiOrientation aAppOrientation )

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiAppUi::SwitchOrientationL" );

    SetOrientationL( aAppOrientation );

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiAppUi::SwitchOrientationL" );

    }

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

//

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

//

void CMusUiAppUi::HandleError( const TInt aReason )

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiAppUi::HandleError" );

    if ( aReason != KErrNone )

        {

        HandleExit();

        }

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

    }

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

//

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

//

void CMusUiAppUi::HandleExit()

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiAppUi::HandleExit" );

    if ( !iExit )

        {

        iExit = ETrue;

        PrepareToExit();

        RemoveView( KMusUidLiveSharingView );

        RemoveView( KMusUidClipSharingView );

        RemoveView( KMusUidReceivingView );

        iExiting = EFalse;

        User::Exit( KErrNone );

        }

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiAppUi::HandleExit" );

    }

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

//

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

//

TBool CMusUiAppUi::OrientationCanBeChanged() const

    {

    return CAknAppUiBase::OrientationCanBeChanged();

    }