/*

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

#include "musuieventobserver.h"

#include "musuisharingobserver.h"

#include "musuipropertywatch.h"

#include "musuicallbackservice.h"

#include "musuiactivitymanger.h"

#include "musuifileutil.h"

#include "musuidialogutil.h"

#include "musuicontactutil.h"

#include "mussessionproperties.h"

#include "musuibitmapdecoder.h"

#include "muscommon.h"

#include "mussettings.h"

#include "musenguriparser.h"

#include "musuimmcmonitor.h"

#include "musresourceproperties.h"

#include "musuiresourcehandler.h"

#include "musui.hrh"

#include "muslogger.h" // debug logging

#include "musuigeneralview.h"

#include "musengmcesession.h"

#include <musui.rsg>

#include <fbs.h>

#include <e32property.h>

#include <StringLoader.h>

#include <pathinfo.h>

#include <featmgr.h>

#include <bldvariant.hrh> // for feature definitions

#include <pathconfiguration.hrh>

#include <hlplch.h> // HlpLauncher

#include <AknUtils.h>

using namespace MusSettingsKeys;

using namespace NMusSessionApi;

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

//

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

//

CMusUiEventController::~CMusUiEventController()

    {

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

    delete iResourceHandler;

    delete iStatusPropertyWatch;    

    delete iContactName;

    delete iTelNumber;

    delete iVideoCodec;

    delete iDialogPrompt;

    delete iCallbackService;

    delete iMmcMonitor;

    delete iActivityManager;

    FeatureManager::UnInitializeLib();

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

    }

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

//

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

//

void CMusUiEventController::ConstructL()

    {

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

    TInt error( KErrNotFound );

    FeatureManager::InitializeLibL();

    iCallbackService = CMusUiCallbackService::NewL( *this );

    // read ps properties (no need to read again later)

    TRAP( error, iVideoCodec = CMusUiPropertyWatch::ReadDescPropertyL(

                            KVideoCodecs ) );

    if ( error != KErrNone )

        {

        iVideoCodec = KNullDesC().AllocL();

        }

    TRAP( error, iTelNumber = CMusUiPropertyWatch::ReadDescPropertyL(

                            KTelNumber ) );

    if ( error != KErrNone )

        {

        iTelNumber = KNullDesC().AllocL();

        }

    TRAP( error, iSipProfileId = CMusUiPropertyWatch::ReadIntPropertyL(

                            NMusSessionApi::KSipProfileId ) );

    if ( error != KErrNone )

        {

        iSipProfileId = KErrNotFound;

        }

    TRAP( error,

          iContactId = CMusUiPropertyWatch::ReadIntPropertyL( KContactId ) );

    if ( error != KErrNone )

        {

        iContactId = KErrNotFound;

        }

    TRAP( error, iContactName = CMusUiPropertyWatch::ReadDescPropertyL(

                            KContactName ) );

    if ( error != KErrNone )

        {

        iContactName = KNullDesC().AllocL();

        }

    // follow session status property

    iStatusPropertyWatch = CMusUiPropertyWatch::NewL(

                            *this,

                            NMusSessionApi::KCategoryUid,

                            KStatus );

    iMmcMonitor = CMusUiMmcMonitor::NewL( *this );

    iResourceHandler = CMusUiResourceHandler::NewL( iEventObserver );

    // start monitoring activity

    iActivityManager = CMusUiActivityManager::NewL( KMusBacklightTimeOut );

    iActivityManager->Reset();

    // check if operator specific functionality is needed  

    iOperatorSpecificFunctionality = 

        ( MultimediaSharingSettings::OperatorVariantSettingL() == 

                                                    EOperatorSpecific );

    iShutdownState = EMusUiShutdownNotDefined;

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

    }

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

//

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

//

CMusUiEventController::CMusUiEventController(

                            MMusUiEventObserver& aEventObserver,

                            MMusUiSharingObserver& aSharingObserver )

    : iEventObserver( aEventObserver ),

      iSharingObserver( aSharingObserver ),

	  iForeground( ETrue ),

	  iActiveCall( ETrue )      

    {

    }

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

// Called by CMusUiPropertyWatch, when resource key values change in P&S

// Sets the member values common to all sharing types.

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

//

void CMusUiEventController::PropertyChanged( const TUint aKey,

                                                     const TInt aValue )

    {

    MUS_LOG2( "mus: [MUSUI ] -> CMusUiEventController::ResourcePropertyChanged:\

              aKey: [%u] aValue: [%d]", aKey, aValue );

    switch( aKey )

        {

        case KStatus:

            {

            TRAP_IGNORE(

                    HandleChangedStatusL( ( TMusAvailabilityStatus ) aValue ) );

            break;

            }

        default:

            {

            break;

            }

        }

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

    }

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

//

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

//

void CMusUiEventController::HandlePropertyError( const TInt aReason )

    {

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

                            aReason );

    HandleError( aReason );

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

    }

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

//

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

//

void CMusUiEventController::HandleAsyncEventL( TMusUiAsyncEvent aEventId )

    {

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

              aEventId );

    switch ( aEventId )

        {

        case EMusUiAsyncHandleExit:

            {

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

                                    HandleAsyncEventL: EMusUiAsyncHandleExit" );

            HandleExitL();

            break;

            }

        default:

            {

            break;

            }

        }

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

    }

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

//

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

//

TInt CMusUiEventController::HandleAsyncError( TInt aError )

    {

    iEventObserver.HandleError( aError ); // Stop the execution

    return KErrNone;

    }

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

//

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

//

void CMusUiEventController::MmcRemoved()

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiEventController::MmcRemoved" );

    TRAP_IGNORE( MusUiDialogUtil::ShowInformationDialogL( 

                            R_MUS_LIVE_SHARING_VIEW_NOTE_SHARING_ENDED ) )

    iEventObserver.HandleExit();

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

    }

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

//

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

//

void CMusUiEventController::SessionEstablished()

    {

    TRAPD( error, iSharingObserver.ShowStatusPaneTitleL() )

    if ( error != KErrNone )    

        {

        iEventObserver.HandleError( error );

        }

    if ( MUS_NO_TOOLBAR )

        {

        TRAPD( error, iSharingObserver.EnableMiddleSoftkeyL( IsLoudSpeakerEnabled() ? 

                            R_MUSUI_VIEW_OPS_MSK_IHF_OFF :

                            R_MUSUI_VIEW_OPS_MSK_IHF_ON ));

        if ( error != KErrNone )    

            {

            iEventObserver.HandleError( error );

            }        

        }

    }

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

//

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

//

void CMusUiEventController::AudioRoutingChanged( TBool aShowNote )

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiEventController::AudioRoutingChanged" );

    if ( aShowNote )

        {

        if ( IsLoudSpeakerEnabled() )

            {

            MUS_LOG( "mus: [MUSUI ]     show activated note" );

            TRAP_IGNORE( 

            	MusUiDialogUtil::ShowGlobalInformationDialogL( R_MUS_NOTE_HF_ACTIVATED ) )

            }

        }

    iSharingObserver.RefreshAudioRoutingToolbarButton();

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

    }

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

//

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

//

TBool CMusUiEventController::AudioRouteChangeAllowed() const

    {

    // Do not allow audio routing if call has ended

    return iActiveCall;

    }

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

//

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

//

void CMusUiEventController::SetRect(const TRect& aRect)

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiEventController::SetRect" );

    if ( EngineSession() )

        {

        TRAPD( err, EngineSession()->SetRectL( aRect ) );

        if ( err != KErrNone )

            {

            iEventObserver.HandleError( err );

            }

        }

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

    }

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

//

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

//

const TDesC& CMusUiEventController::MusContactName()

    {

    return *iContactName;

    }

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

//

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

//

const TDesC& CMusUiEventController::MusVideoCodecValue()

    {

    return *iVideoCodec;

    }

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

//

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

//

const TDesC& CMusUiEventController::MusTelNumberValue()

    {

    MUS_LOG_TDESC("mus: [MUSUI ] <> CMusUiEventController::MusTelNumberValue()",

                   iTelNumber->Des() )

    return *iTelNumber;

    }

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

//

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

//

const TDesC& CMusUiEventController::SessionTimeFormatted(

                        const TTimeIntervalSeconds& aSeconds )

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiEventController::SessionTimeFormatted" );

    iTimeBuffer.SetLength( 0 );

    TLocale locale;

    _LIT( KZeroSymbol, "0" );

    TInt sessionHours( 0 );

    TInt sessionMinutes( 0 );

    TInt sessionSeconds( aSeconds.Int() );

    if ( aSeconds.Int() > ( KMusOneMinuteInSeconds - 1 ) )

        {

        sessionMinutes = (int)(aSeconds.Int() / KMusOneMinuteInSeconds );

        sessionSeconds = sessionSeconds - ( sessionMinutes * KMusOneMinuteInSeconds );

        }

    if ( sessionMinutes > ( KMusOneMinuteInSeconds - 1 ) )

        {

        sessionHours = (int)( sessionMinutes / KMusOneMinuteInSeconds );

        sessionMinutes = sessionMinutes - ( sessionHours * KMusOneMinuteInSeconds );

        }

    if ( sessionHours != 0 )

        {

        iTimeBuffer.AppendNum( sessionHours );

        iTimeBuffer.Append( locale.TimeSeparator( KMusLocaleHoursAndMinutesSeparator ) );

        if ( sessionMinutes < KMusNumberValueTen )

            {

            iTimeBuffer.Append( KZeroSymbol );

            }

        }

    iTimeBuffer.AppendNum( sessionMinutes );

    iTimeBuffer.Append( locale.TimeSeparator( KMusLocaleMinutesAndSecondsSeparator ) );

    if ( sessionSeconds < KMusNumberValueTen )

        {

        iTimeBuffer.Append( KZeroSymbol );

        }

    iTimeBuffer.AppendNum( sessionSeconds );

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

    return iTimeBuffer;

    }

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

//

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

//

void CMusUiEventController::SaveContactQueryL()

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiEventController::SaveContactQueryL" );

    if ( !MusUiContactUtil::ShareViewFieldExistsL( *iEventObserver.EikonEnv(), 

                                                   iContactId ) )

        {

        delete iDialogPrompt;

        iDialogPrompt = NULL;

        iDialogPrompt = StringLoader::LoadL( R_MUS_VIEW_SAVE_ADDRESS_QUERY_TXT );

        iEventObserver.ShowAsyncConfirmationQueryDialogL( *iDialogPrompt );

        }

    else

        {

        AsyncQueryDialogAcceptedL( EFalse );

        }

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

    }

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

//

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

//

void CMusUiEventController::HandleError( const TInt aError )

    {

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

              aError );

    iEventObserver.HandleError( aError );

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

    }

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

//

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

//

TBool CMusUiEventController::ExitOccured()

    {

    return ( iShutdownState != EMusUiShutdownNotDefined );

    }

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

//

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

//

TBool CMusUiEventController::AudioRoutingCanBeChanged()

    {

    return ( EngineSession() && EngineSession()->AudioRoutingCanBeChanged() );

    }

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

//

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

//

TBool CMusUiEventController::IsLoudSpeakerEnabled()

    {

    return ( EngineSession() && EngineSession()->IsLoudSpeakerEnabled() );

    }

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

//

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

//

TBool CMusUiEventController::DeviceHasDedicatedVolumeKeys()

    {

    return FeatureManager::FeatureSupported( KFeatureIdSideVolumeKeys );

    }

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

//

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

//

void CMusUiEventController::HandleExitL()

    {

    MUS_LOG( "mus: [MUSUI ]  -> CMusUiEventController::HandleExitL" );

    if ( iShutdownState == EMusUiShutdownNotDefined )

        {

        iShutdownState = EMusUiShutdownStarted;

        if ( iStatusPropertyWatch )

            {

            iStatusPropertyWatch->Cancel();    

            }

        if ( iMmcMonitor )

            {

            iMmcMonitor->Cancel();    

            }