--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mmsharing/mmshui/src/musuieventcontroller.cpp Wed Sep 01 12:31:01 2010 +0100
@@ -0,0 +1,1124 @@
+/*
+* 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>
+#include <telmicmutestatuspskeys.h>
+
+using namespace MusSettingsKeys;
+using namespace NMusSessionApi;
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+CMusUiEventController::~CMusUiEventController()
+ {
+ MUS_LOG( "mus: [MUSUI ] -> CMusUiEventController::~CMusUiEventController" );
+ delete iStatusPropertyWatch;
+ delete iContactName;
+ delete iTelNumber;
+ delete iVideoCodec;
+ delete iDialogPrompt;
+ delete iCallbackService;
+ delete iMmcMonitor;
+ delete iActivityManager;
+ delete iMicMuteStatusPropertyWatch;
+ 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 = iEventObserver.ResourceHandler();
+ __ASSERT_ALWAYS( iResourceHandler, User::Leave( KErrNotFound ) );
+
+ //Mic mute status property
+ iMicMuteStatusPropertyWatch = CMusUiPropertyWatch::NewL(
+ *this,
+ KPSUidTelMicrophoneMuteStatus,
+ KTelMicrophoneMuteState );
+
+ // 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 ),
+ iShowDialog( EFalse ),
+ 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 KTelMicrophoneMuteState:
+ {
+ if ( aValue == EPSTelMicMuteOff)
+ {
+ iSharingObserver.ReplaceToolbarCommand( EMusuiCmdToolbarUnmute,
+ EMusuiCmdToolbarMute,ETrue );
+ }
+ else if ( aValue == EPSTelMicMuteOn )
+ {
+ iSharingObserver.ReplaceToolbarCommand( EMusuiCmdToolbarMute,
+ EMusuiCmdToolbarUnmute,ETrue );
+ }
+ break;
+ }
+ 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::VolumeChanged( TInt aVolume, TBool aAudioRouteChanged )
+ {
+ // Set Volume:
+ //If volume changed due to audio route change, we want to update volume
+ //popup control only if it is already visible
+ TBool onlyIfVisible = aAudioRouteChanged;
+ TRAP_IGNORE( iSharingObserver.ActivateVolumeControlL(aVolume, onlyIfVisible) );
+ }
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+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( TBool aTerminateCall )
+ {
+ MUS_LOG( "mus: [MUSUI ] -> CMusUiEventController::HandleExitL" );
+ if ( iShutdownState == EMusUiShutdownNotDefined )
+ {
+ iShutdownState = EMusUiShutdownStarted;
+
+ if ( iStatusPropertyWatch )
+ {
+ iStatusPropertyWatch->Cancel();
+ }
+
+ if ( iMmcMonitor )
+ {
+ iMmcMonitor->Cancel();
+ }
+
+ if ( iActivityManager )
+ {
+ iActivityManager->Cancel();
+ }
+
+ if ( iCallbackService )
+ {
+ iCallbackService->Cancel();
+ }
+
+ iEventObserver.SetToolbarVisibility( EFalse );
+
+ // This must be done before showing the end note, because showing of
+ // note may cause the session to continue for extra few seconds.
+ DeleteEngineSession();
+ if ( iShowDialog )
+ {
+ MusUiDialogUtil::ShowGlobalInformationDialogL(
+ R_MUS_NOTE_HF_DEACTIVATED );
+ }
+ // Sharing Ended note
+ MusUiDialogUtil::ShowGlobalInformationDialogL(
+ R_MUS_LIVE_SHARING_VIEW_NOTE_SHARING_ENDED );
+
+ if( aTerminateCall )
+ {
+ iEventObserver.TerminateCall();
+ }
+
+ // TODO: Continue Recording query, if sharing live video and receiving end
+ // terminates the sharing session
+
+ ExitProcedureL( EFalse );
+
+ }
+ MUS_LOG( "mus: [MUSUI ] <- CMusUiEventController::HandleExitL" );
+ }
+
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CMusUiEventController::ExitProcedureL( TBool aUserAcceptance )
+ {
+ MUS_LOG( "mus: [MUSUI ] -> CMusUiEventController::ExitProcedureL" );
+
+ iSharingObserver.DismissMenuBar();
+
+ switch ( iShutdownState )
+ {
+ case EMusUiShutdownStarted:
+ {
+ MUS_LOG( "mus: [MUSUI ] ExitProcedureL: EMusUiShutdownStarted" );
+ // No general functionality, skip the state
+ iShutdownState = EMusUiShutdownVideoSaved;
+ ExitProcedureL( EFalse );
+ break;
+ }
+ case EMusUiShutdownVideoSaved:
+ {
+ MUS_LOG( "mus: [MUSUI ] ExitProcedureL: EMusuiShutdownVideoSaved" );
+ iEventObserver.HandleExit();
+ break;
+ }
+
+ case EMusUiShutdownContactSavingQueried:
+ {
+ MUS_LOG( "mus: [MUSUI ] ExitProcedureL: EMusUiShutdownContactSavingQueried" );
+ // Stop app execution
+ if ( aUserAcceptance )
+ {
+ if ( iResourceHandler->RequestKeypadL( EFalse ) )
+ {
+ MusUiContactUtil::ActivateContactViewL(
+ *iEventObserver.EikonEnv(),
+ iContactId,
+ TypedAddress(),
+ MusTelNumberValue() );
+ }
+ }
+ iEventObserver.HandleExit();
+ break;
+ }
+ case EMusUiShutdownOver:
+ {
+ iEventObserver.HandleExit();
+ break;
+ }
+ case EMusUiShutdownNotDefined:
+ default:
+ {
+ break;
+ }
+ }
+
+ MUS_LOG( "mus: [MUSUI ] <- CMusUiEventController::ExitProcedureL" );
+ }
+
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CMusUiEventController::AsyncQueryDialogAcceptedL( TBool aAccepted )
+ {
+ MUS_LOG( "mus: [MUSUI ] -> CMusUiEventController::AsyncQueryDialogAcceptedL" );
+
+ if ( ExitOccured() )
+ {
+ ExitProcedureL( aAccepted );
+ }
+
+ MUS_LOG( "mus: [MUSUI ] <- CMusUiEventController::AsyncQueryDialogAcceptedL" );
+ }
+
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+TBool CMusUiEventController::ConnectionEstablished() const
+ {
+ return iConnectionEstablished;
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CMusUiEventController::SetConnectionInitialized(
+ TBool aConnectionInitialized )
+ {
+ MUS_LOG1(
+ "mus: [MUSUI ] -> CMusUiEventController::SetConnectionInitialized ( %d )",
+ aConnectionInitialized );
+
+ iConnectionInitialized = aConnectionInitialized;
+
+ if ( !iForeground && !ExitOccured() )
+ {
+ TRAP_IGNORE( EnableDisplayL(EFalse) )
+ }
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+TBool CMusUiEventController::ConnectionInitialized() const
+ {
+ return iConnectionInitialized;
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CMusUiEventController::EnableDisplayL( TBool aEnable )
+ {
+ MUS_LOG( "mus: [MUSUI ] -> CMusUiEventController::EnableDisplayL" );
+ if ( EngineSession() )
+ {
+ EngineSession()->EnableDisplayL( aEnable );
+ }
+ MUS_LOG( "mus: [MUSUI ] <- CMusUiEventController::EnableDisplayL" );
+ }
+
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CMusUiEventController::ChangeOrientationL(
+ CAknAppUiBase::TAppUiOrientation aOrientation )
+ {
+ MUS_LOG( "mus: [MUSUI ] -> CMusUiEventController::ChangeOrientationL" );
+ iEventObserver.SwitchOrientationL( aOrientation );
+ MUS_LOG( "mus: [MUSUI ] <- CMusUiEventController::ChangeOrientationL" );
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+TBool CMusUiEventController::IsDisplayEnabledL()
+ {
+ MUS_LOG( "mus: [MUSUI ] -> CMusUiEventController::IsDisplayEnabledL" );
+ TBool ret = EFalse;
+ if ( EngineSession() )
+ {
+ ret = EngineSession()->IsDisplayEnabledL();
+ }
+ MUS_LOG1( "mus: [MUSUI ] <- CMusUiEventController::IsDisplayEnabledL, %d", ret );
+ return ret;
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+TBool CMusUiEventController::IsAudioRoutingLoudSpeaker()
+ {
+ MUS_LOG( "mus: [MUSUI ] -> CMusUiEventController::IsAudioRoutingLoudSpeaker" );
+ TBool ret = EFalse;
+ if ( EngineSession() )
+ {
+ ret = EngineSession()->IsAudioRoutingLoudSpeaker();
+ }
+ MUS_LOG1( "mus: [MUSUI ] <- CMusUiEventController::IsAudioRoutingLoudSpeaker, %d", ret );
+ return ret;
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+TBool CMusUiEventController::ToolbarVolumeSelected()
+ {
+ return iToolbarVolumeSelected;
+ }
+
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+TBool CMusUiEventController::IsMicMutedL()
+ {
+ __ASSERT_ALWAYS( EngineSession(), User::Leave( KErrNotReady ) );
+
+ return EngineSession()->IsMicMutedL();
+ }
+
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+TBool CMusUiEventController::ManualAddressTyped() const
+ {
+ return EFalse;
+ }
+
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CMusUiEventController::HandleForegroundEventL( TBool aForeground )
+ {
+ MUS_LOG( "mus: [MUSUI ] -> CMusUiEventController::HandleForegroundEventL" );
+
+ iForeground = aForeground;
+
+ if ( ConnectionInitialized() && !ExitOccured() )
+ {
+ EnableDisplayL( aForeground );
+
+ // Change toolbar according to a real state. Other items than speaker
+ // and mic states cannot be changed from phone app and thus there is
+ // no need to check them
+ if ( aForeground )
+ {
+ if ( MUS_NO_TOOLBAR )
+ {
+ iSharingObserver.EnableMiddleSoftkeyL( IsLoudSpeakerEnabled() ?
+ R_MUSUI_VIEW_OPS_MSK_IHF_OFF :
+ R_MUSUI_VIEW_OPS_MSK_IHF_ON );
+ }
+ else
+ {
+ if ( IsMicMutedL() )
+ {
+ iSharingObserver.ReplaceToolbarCommand( EMusuiCmdToolbarMute,
+ EMusuiCmdToolbarUnmute,
+ EFalse );
+ }
+ else
+ {
+ iSharingObserver.ReplaceToolbarCommand( EMusuiCmdToolbarUnmute,
+ EMusuiCmdToolbarMute,
+ EFalse );
+ }
+
+ if ( IsLoudSpeakerEnabled() )
+ {
+ iSharingObserver.ReplaceToolbarCommand(
+ EMusuiCmdToolbarSpeakerOn,
+ EMusuiCmdToolbarSpeakerOff,
+ EFalse );
+ }
+ else
+ {
+ iSharingObserver.ReplaceToolbarCommand(
+ EMusuiCmdToolbarSpeakerOff,
+ EMusuiCmdToolbarSpeakerOn,
+ EFalse );
+ }
+ if ( ConnectionEstablished() )
+ {
+ iEventObserver.SetToolbarVisibility( aForeground );
+ }
+
+ }
+ }
+
+ }
+
+
+ MUS_LOG( "mus: [MUSUI ] <- CMusUiEventController::HandleForegroundEventL" );
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+TBool CMusUiEventController::IsForeground() const
+ {
+ return iForeground;
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CMusUiEventController::OfferToolbarEventL( TInt aCommand )
+ {
+ MUS_LOG1( "mus: [MUSUI ] -> CMusUiEventController::OfferToolbarEventL [%d]",
+ aCommand );
+
+ __ASSERT_ALWAYS( EngineSession(), User::Leave( KErrNotReady ) );
+
+ switch ( aCommand )
+ {
+ case EMusuiCmdToolbarVolume:
+ {
+ iToolbarVolumeSelected = !iToolbarVolumeSelected;
+ iSharingObserver.HighlightSelectedToolbarItem(
+ EMusuiCmdToolbarVolume );
+ iSharingObserver.ActivateVolumeControlL(
+ EngineSession()->VolumeL() );
+ break;
+ }
+ case EMusuiCmdToolbarMute:
+ {
+ EngineSession()->MuteMicL( ETrue );
+ iSharingObserver.ReplaceToolbarCommand( EMusuiCmdToolbarMute,
+ EMusuiCmdToolbarUnmute,
+ ETrue );
+ break;
+ }
+ case EMusuiCmdToolbarUnmute:
+ {
+ EngineSession()->MuteMicL( EFalse );
+ iSharingObserver.ReplaceToolbarCommand( EMusuiCmdToolbarUnmute,
+ EMusuiCmdToolbarMute,
+ ETrue );
+ break;
+ }
+ case EMusuiCmdToolbarSpeakerOff:
+ {
+ EngineSession()->EnableLoudspeakerL( ELoudspeakerDisabled, EFalse );
+ // Toolbar will be changed when asynchronous request is completed
+ break;
+ }
+ case EMusuiCmdToolbarSpeakerOn:
+ {
+ EngineSession()->EnableLoudspeakerL( ELoudspeakerEnabled, EFalse );
+ // Toolbar will be changed when asynchronous request is completed
+ break;
+ }
+ default: // Never should be the case
+ {
+ HandleExitL();
+ break;
+ }
+
+ }
+
+ MUS_LOG1( "mus: [MUSUI ] <- CMusUiEventController::OfferToolbarEventL [%d]",
+ aCommand );
+
+ }
+
+
+// -----------------------------------------------------------------------------
+// Handles commands common to all sharing types.
+// -----------------------------------------------------------------------------
+//
+void CMusUiEventController::HandleCommandL( TInt aCommand )
+ {
+ MUS_LOG( "mus: [MUSUI ] -> CMusUiEventController::HandleCommandL" );
+
+ switch ( aCommand )
+ {
+ case EMusuiCmdViewVolumeUp:
+ {
+ // Set Volume:
+ __ASSERT_ALWAYS( EngineSession(), User::Leave( KErrNotReady ) );
+ EngineSession()->VolumeUpL();
+ // Status pane update will be done later. When we get
+ // VolumeChanged() callback
+ break;
+ }
+ case EMusuiCmdViewVolumeDown:
+ {
+ // Set Volume:
+ __ASSERT_ALWAYS( EngineSession(), User::Leave( KErrNotReady ) );
+ EngineSession()->VolumeDownL();
+ // Status pane update will be done later. When we get
+ // VolumeChanged() callback
+ break;
+ }
+ case EMusuiCmdViewVolumeChanged:
+ {
+ __ASSERT_ALWAYS( EngineSession(), User::Leave( KErrNotReady ) );
+ TInt volumeFromEngine = EngineSession()->VolumeL();
+ TInt volumeFromUi = iEventObserver.GetUiVolumeValue();
+ if ( volumeFromUi != volumeFromEngine )
+ {
+ EngineSession()->SetVolumeL( volumeFromUi );
+ }
+ break;
+ }
+
+ case EMusuiCmdViewLoadspeaker:
+ {
+ EngineSession()->EnableLoudspeakerL( ELoudspeakerEnabled, ETrue );
+ break;
+ }
+
+ case EMusuiCmdViewHandset:
+ {
+ EngineSession()->EnableLoudspeakerL( ELoudspeakerDisabled, ETrue );
+ break;
+ }
+
+ case EMusuiCmdViewMicrophoneMute:
+ {
+ EngineSession()->MuteMicL( ETrue );
+ break;
+ }
+
+ case EMusuiCmdViewMicrophoneUnmute:
+ {
+ EngineSession()->MuteMicL( EFalse );
+ break;
+ }
+
+ case EMusuiCmdViewEndActiveCall:
+ {
+ MUS_LOG( "mus: [MUSUI ] CMusUiReceiveController::ConstructL:\
+ EMusuiCmdViewEndActiveCall" );
+ HandleExitL( ETrue );
+ break;
+ }
+ case EMusuiGenCmdExit:
+ case EAknSoftkeyExit:
+ {
+ HandleExitL();
+ break;
+ }
+
+ case EAknCmdHelp:
+ {
+ if ( FeatureManager::FeatureSupported( KFeatureIdHelp ) )
+ {
+ HlpLauncher::LaunchHelpApplicationL(
+ iEventObserver.EikonEnv()->WsSession(),
+ iEventObserver.EikonEnv()->AppUi()->AppHelpContextL() );
+ }
+ break;
+ }
+
+ default:
+ {
+ //NOP
+ break;
+ }
+ }
+
+ MUS_LOG( "mus: [MUSUI ] <- CMusUiEventController::HandleCommandL" );
+ }
+
+
+// -----------------------------------------------------------------------------
+// Handles status changes common to all sharing types.
+// -----------------------------------------------------------------------------
+//
+void CMusUiEventController::HandleChangedStatusL(
+ TMusAvailabilityStatus aStatus )
+ {
+ MUS_LOG( "mus: [MUSUI ] -> CMusUiEventController::HandleChangedStatusL" );
+ switch( aStatus )
+ {
+ case EErrNoActiveCall:
+ {
+ MUS_LOG( "mus: [MUSUI ] EErrNoActiveCall" );
+ iActiveCall = EFalse;
+ HandleExitL();
+ break;
+ }
+ case EErrCallOnHold:
+ case EErrConferenceCall:
+ case EMultimediaSharingNotAvailable:
+ {
+ MUS_LOG( "mus: [MUSUI ]\
+ EErrCallOnHold, EErrConferenceCall, EMultimediaSharingNotAvailable" );
+ HandleExitL();
+ break;
+ }
+ case EErrSipRegistration:
+ {
+ MUS_LOG( "mus: [MUSUI ] EErrSipRegistration" );
+ MusUiDialogUtil::ShowInformationDialogL(
+ R_MUS_LIVE_SHARING_VIEW_NOTE_SERVICE_N_A );
+ HandleExitL();
+ break;
+ }
+ case EErrRoaming:
+ {
+ MUS_LOG( "mus: [MUSUI ] EErrRoaming" );
+ HandleExitL();
+ break;
+ }
+ case EErrNetwork:
+ {
+ MUS_LOG( "mus: [MUSUI ] EErrNetwork" );
+ MusUiDialogUtil::ShowInformationDialogL(
+ R_MUS_LIVE_SHARING_VIEW_NOTE_SERVICE_N_A );
+ HandleExitL();
+ break;
+ }
+ case EErrConnection:
+ {
+ MUS_LOG( "mus: [MUSUI ] EErrConnection" );
+ MusUiDialogUtil::ShowInformationDialogL(
+ R_MUS_LIVE_SHARING_VIEW_NOTE_ONLY_3G );
+ HandleExitL();
+ break;
+ }
+
+ case EErrServerShutDown:
+ {
+ MUS_LOG( "mus: [MUSUI ] EErrServerShutDown" );
+ HandleExitL();
+ break;
+ }
+
+ default:
+ {
+ MUS_LOG( "mus: [MUSUI ] Default" );
+ // TODO
+ break;
+ }
+ }
+ MUS_LOG( "mus: [MUSUI ] <- CMusUiEventController::HandleChangedStatusL" );
+ }
+
+