--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mmsharing/mmshui/src/musuisendcontroller.cpp Wed Sep 01 12:31:01 2010 +0100
@@ -0,0 +1,1077 @@
+/*
+* 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 (
+ MusUiDialogUtil::ShowInformationDialogL(
+ R_MUS_LIVE_SHARING_VIEW_NOTE_CONNECTION_REJECTED ) );
+
+ 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 ) );
+
+ MUS_LOG( "mus: [MUSUI ] <- CMusUiSendController::SessionProxyAuthenticationRequired" );
+ }
+
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CMusUiSendController::SessionRequestTimeOut()
+ {
+ MUS_LOG( "mus: [MUSUI ] -> CMusUiSendController::SessionRequestTimeOut" );
+ DismissWaitDialog();
+ TRAP_IGNORE( MusUiDialogUtil::ShowInformationDialogL(
+ R_MUS_LIVE_SHARING_VIEW_NOTE_NO_RESPONSE ) );
+
+ TRAP_IGNORE( iCallbackService->AsyncEventL( EMusUiAsyncHandleExit ) );
+
+ MUS_LOG( "mus: [MUSUI ] <- CMusUiSendController::SessionRequestTimeOut" );
+ }
+
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CMusUiSendController::SessionUnsupportedMediaType()
+ {
+ MUS_LOG( "mus: [MUSUI ] -> CMusUiSendController::SessionUnsupportedMediaType" );
+ DismissWaitDialog();
+ if ( !ExitOccured() )
+ {
+ TRAP_IGNORE( MusUiDialogUtil::ShowGlobalErrorDialogL(
+ R_MUS_LIVE_SHARING_VIEW_NOTE_APP_N_A ) );
+ }
+
+ TRAP_IGNORE( iCallbackService->AsyncEventL( EMusUiAsyncHandleExit ) );
+
+ MUS_LOG( "mus: [MUSUI ] <- CMusUiSendController::SessionUnsupportedMediaType" );
+ }
+
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CMusUiSendController::SessionBusyHere()
+ {
+ MUS_LOG( "mus: [MUSUI ] -> CMusUiSendController::SessionBusyHere" );
+ DismissWaitDialog();
+ TRAP_IGNORE(
+ MusUiDialogUtil::ShowInformationDialogL(
+ R_MUS_LIVE_SHARING_VIEW_NOTE_RECIPIENT_N_A ) );
+
+ TRAP_IGNORE( iCallbackService->AsyncEventL( EMusUiAsyncHandleExit ) );
+
+ MUS_LOG( "mus: [MUSUI ] <- CMusUiSendController::SessionBusyHere" );
+ }
+
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CMusUiSendController::SessionRequestCancelled()
+ {
+ MUS_LOG( "mus: [MUSUI ] -> CMusUiSendController::SessionRequestCancelled" );
+ DismissWaitDialog();
+ TRAP_IGNORE(
+ MusUiDialogUtil::ShowInformationDialogL(
+ R_MUS_LIVE_SHARING_VIEW_NOTE_INVITATION_CANCELLED ) );
+
+ TRAP_IGNORE( iCallbackService->AsyncEventL( EMusUiAsyncHandleExit ) );
+
+ MUS_LOG( "mus: [MUSUI ] <- CMusUiSendController::SessionRequestCancelled" );
+ }
+
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CMusUiSendController::SessionTemporarilyNotAvailable()
+ {
+ MUS_LOG( "mus: [MUSUI ] -> CMusUiSendController::SessionRequestCancelled" );
+ DismissWaitDialog();
+ if ( !ExitOccured() )
+ {
+ TRAP_IGNORE( MusUiDialogUtil::ShowGlobalErrorDialogL(
+ R_MUS_LIVE_SHARING_VIEW_NOTE_SERVICE_N_A ) );
+ }
+
+ TRAP_IGNORE( iCallbackService->AsyncEventL( EMusUiAsyncHandleExit ) );
+
+ MUS_LOG( "mus: [MUSUI ] <- CMusUiSendController::SessionRequestCancelled" );
+ }
+
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CMusUiSendController::ConstructL()
+ {
+ MUS_LOG( "mus: [MUSUI ] -> CMusUiSendController::ConstructL" );
+
+ CMusUiEventController::ConstructL(); // Base class construction
+ iLocalizer = CDirectoryLocalizer::NewL();
+
+ MUS_LOG( "mus: [MUSUI ] <- CMusUiSendController::ConstructL" );
+ }
+
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+CMusUiSendController::CMusUiSendController(
+ MMusUiEventObserver& aEventObserver,
+ MMusUiSharingObserver& aSharingObserver,
+ MMusUiSendObserver& aSendObserver )
+ : CMusUiEventController( aEventObserver, aSharingObserver ),
+ iSendObserver( aSendObserver ),
+ iTriedInvitations( 0 ),
+ iContinuePlayingWhenForeground( ETrue ),
+ iWaitDialogCallback( *this )
+ {
+
+ }
+
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CMusUiSendController::ExitProcedureL( TBool aUserAcceptance )
+ {
+ MUS_LOG( "mus: [MUSUI ] -> CMusUiSendController::ExitProcedureL" );
+
+ DismissWaitDialog();
+
+ switch ( iShutdownState )
+ {
+ case EMusUiShutdownStarted:
+ {
+ MUS_LOG( "mus: [MUSUI ] ExitProcedureL: EMusuiShutdownStarted" );
+
+ if ( iVideoToBeSaved &&
+ iVideoFileName &&
+ MusUiFileUtil::FileExists( *iVideoFileName ) )
+ {
+ iShutdownState = EMusUiShutdownVideoSaved;
+ ShowVideoSavedDialogL();
+ ExitProcedureL( ETrue ); // Accept saving
+ }
+ else
+ {
+ CMusUiEventController::ExitProcedureL( aUserAcceptance );
+ }
+ break;
+ }
+
+ case EMusUiShutdownVideoSaved:
+ {
+ MUS_LOG( "mus: [MUSUI ] ExitProcedureL: EMusuiShutdownVideoSaved" );
+
+ // Check if our address is valid sip or tel uri. If not, there is no
+ // point to query user about permission to save it to contacts.
+
+ TInt error = KErrNotFound;
+ if ( iAddress )
+ {
+ TMusEngUriParser parser( *iAddress );
+ TRAP( error, parser.ParseUriL() )
+ }
+
+ // Save Address to Contacts query if manually entered
+ // and if is the standard variant.
+ // NOTE: KErrNotSupported means there is more than one contact id.
+ if ( !iOperatorSpecificFunctionality && ManualAddressTyped() &&
+ iContactId != KErrNotSupported &&
+ error == KErrNone )
+ {
+ iShutdownState = EMusUiShutdownContactSavingQueried;
+ SaveContactQueryL();
+ }
+ else
+ {
+ // Nothing send specific, let the base class handle
+ CMusUiEventController::ExitProcedureL( aUserAcceptance );
+ }
+ break;
+ }
+
+ default:
+ {
+ // Nothing send specific, let the base class handle
+ CMusUiEventController::ExitProcedureL( aUserAcceptance );
+ break;
+ }
+ }
+
+ MUS_LOG( "mus: [MUSUI ] <- CMusUiSendController::ExitProcedureL" );
+ }
+
+
+// -----------------------------------------------------------------------------
+// Handles status changes specific to sending sharing types.
+// Calls base class version for status changes that are not sending specific.
+// -----------------------------------------------------------------------------
+//
+void CMusUiSendController::HandleChangedStatusL(
+ TMusAvailabilityStatus aStatus )
+ {
+ MUS_LOG( "mus: [MUSUI ] -> CMusUiSendController::HandleChangedStatusL" )
+ switch( aStatus )
+ {
+ case ESipRegistrationPending:
+ {
+ MUS_LOG( "mus: [MUSUI ] ESipRegistrationPending" );
+ iSipRegistrationPending = ETrue;
+ break;
+ }
+ case ESipOptionsNotSent: // FALLTHROUGH
+ case ESipOptionsSent: // FALLTHROUGH
+ {
+ break;
+ }
+ case EManualActivation: // FALLTHROUGH
+ case EMultimediaSharingAvailable:
+ {
+ MUS_LOG( "mus: [MUSUI ] EManualActivation or EMultimediaSharingAvailable" )
+
+ if( iSipRegistrationPending )
+ {
+ 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 sending specific, let the base class handle
+ CMusUiEventController::HandleChangedStatusL( aStatus );
+ break;
+ }
+ }
+ MUS_LOG( "mus: [MUSUI ] <- CMusUiSendController::HandleChangedStatusL" )
+ }
+
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+const TDesC& CMusUiSendController::VideoFileNameL()
+ {
+ MUS_LOG( "mus: [MUSUI ] -> CMusUiSendController::VideoFileNameL" );
+
+ TParse parse;
+ TPtrC rootPath;
+
+ SetVideoPathValueL();//sets video rootpath according to setting value.
+
+ if ( parse.Set( iVideoFilePath,NULL,NULL) != KErrBadName )
+ {
+
+ if(parse.Drive().Compare( PathInfo::MemoryCardRootPath()))
+ {
+ TRAPD(error,MusUiFileUtil::VideoFilePathExistsL(iVideoFilePath));
+
+ switch(error)
+ {
+ case KErrNotReady:
+ case KErrCorrupt:
+ case KErrLocked:
+ {
+ MusUiDialogUtil::ShowGlobalInformationDialogL(
+ R_MUS_VIEW_NOTE_MEMORYCARD_PROBLEM);
+
+ MUS_LOG( "mus: [MUSUI ] -> Changing to Phone Memory " );
+ rootPath.Set(PathInfo::PhoneMemoryRootPath());
+ TParsePtrC pathPtr(rootPath);
+ iVideoFilePath = rootPath;
+ iVideoFilePath += PathInfo::VideosPath();
+ // Make sure the new path exists
+ TRAP_IGNORE( MusUiFileUtil::VideoFilePathExistsL(iVideoFilePath) )
+ break;
+ }
+ case KErrAlreadyExists:
+ case KErrNone:
+ {
+ MUS_LOG( "mus: [MUSUI ] -> Using MMC " );
+ rootPath.Set(PathInfo::MemoryCardRootPath());
+ break;
+ }
+ default:
+ {
+ delete iVideoFileName;
+ iVideoFileNamePlain = KNullDesC;
+ iVideoFileName = iVideoFileNamePlain.AllocL();
+ HandleError( error);
+ break;
+ }
+ }
+ }
+ else//Phone memory is being used.
+ {
+ TRAPD(error,MusUiFileUtil::VideoFilePathExistsL(iVideoFilePath));
+
+ switch(error)
+ {
+ case KErrAlreadyExists:
+ case KErrNone:
+ {
+ MUS_LOG( "mus: [MUSUI ] -> Using Phone memory" );
+ rootPath.Set(PathInfo::PhoneMemoryRootPath());
+ break;
+ }
+ default:
+ {
+ delete iVideoFileName;
+ iVideoFileNamePlain = KNullDesC;
+ iVideoFileName = iVideoFileNamePlain.AllocL();
+ HandleError( error);
+ break;
+ }
+ }
+ }
+
+ }
+ else
+ {
+ delete iVideoFileName;
+ iVideoFileNamePlain = KNullDesC;
+ iVideoFileName = iVideoFileNamePlain.AllocL();
+ HandleError(KErrBadName);
+ }
+
+ TParsePtrC pathPtr(rootPath);
+ iVideoFilePath += pathPtr.NameAndExt();
+ MusUiFileUtil::CreateVideoFileNameL(iVideoFilePath,
+ iVideoFileNamePlain);
+
+ delete iVideoFileName;
+ TFileName videoFileName;
+ videoFileName += iVideoFilePath;
+ videoFileName += iVideoFileNamePlain;
+ videoFileName += KMusVideoFileNameExtension;
+ iVideoFileName = videoFileName.AllocL();
+
+ MUS_LOG_TDESC( "mus: [MUSUI ] <- CMusUiSendController::VideoFileNameL:",
+ iVideoFileName->Des() );
+ return *iVideoFileName;
+ }
+
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CMusUiSendController::ShowInvitingWaitDialogL()
+ {
+ MUS_LOG( "mus: [MUSUI ] -> CMusUiSendController::ShowWaitDialogL" );
+ delete iDialogPrompt;
+ iDialogPrompt = NULL;
+ iDialogPrompt = StringLoader::LoadL(
+ R_MUS_LIVE_SHARING_VIEW_INVITING_WAIT_NOTE_TXT,
+ MusContactName().Length() > 0 ?
+ MusContactName() : iOperatorSpecificFunctionality ?
+ MusTelNumberValue() : *iAddress );
+
+ if ( !iSharingObserver.ShowWaitDialogL(
+ *iDialogPrompt,
+ KMusInviteExpireTimeout,
+ R_MUS_LIVE_SHARING_VIEW_NOTE_NO_RESPONSE ) )
+ {
+ CancelInvitationL();
+ }
+
+
+ MUS_LOG( "mus: [MUSUI ] <- CMusUiSendController::ShowWaitDialogL" );
+ }
+
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CMusUiSendController::DismissWaitDialog()
+ {
+ MUS_LOG( "mus: [MUSUI ] -> CMusUiSendController::DismissWaitDialog" );
+ TRAPD( err, iSharingObserver.DismissWaitDialogL(); );
+ if ( err != KErrNone )
+ {
+ HandleError( err );
+ }
+ MUS_LOG( "mus: [MUSUI ] <- CMusUiSendController::DismissWaitDialog" );
+ }
+
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CMusUiSendController::SplitL( const TDesC& aDes,
+ const TDesC& aChar,
+ CDesCArray* aArray )
+ {
+ TInt charPos( 0 );
+ TPtrC ptr( aDes );
+ TBool found = EFalse;
+ while( ( charPos = ptr.Find( aChar ) ) > 0 )
+ {
+ found = ETrue;
+ TPtrC str = ptr.Left( charPos );
+ aArray->AppendL( str );
+ ptr.Set( ptr.Right( ptr.Length() - str.Length() - 1 ) );
+ }
+ if ( found && ptr.Length() > 0 )
+ {
+ aArray->AppendL( ptr );
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CMusUiSendController::SetVideoPathValueL()
+ {
+ MUS_LOG( "mus: [MUSUI ] -> CMusUiSendController::SetVideoPathValueL" );
+ TInt drive = MultimediaSharingSettings::VideoLocationSettingL();
+
+ TFileName rootPath;
+ User::LeaveIfError( PathInfo::GetRootPath( rootPath, drive ) );
+
+ TParsePtrC pathPtr(rootPath);
+ iVideoFilePath = rootPath;
+ iVideoFilePath += PathInfo::VideosPath();
+ MUS_LOG_TDESC( "mus: [MUSUI ] <- CMusUiSendController::SetVideoPathValueL: ",
+ iVideoFilePath );
+ iLocalizer->SetFullPath( iVideoFilePath );
+ if ( iLocalizer->IsLocalized() )
+ {
+ iLocalizedVideoFilePath =iLocalizer->LocalizedName();
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CMusUiSendController::ShowVideoSavedDialogL()
+ {
+ MUS_LOG( "mus: [MUSUI ] -> CMusUiSendController::ShowVideoSavedDialogL" );
+ //MUS_LOG_TDESC( "mus: [MUSUI ] ", iVideoFileNamePlain );
+ //MUS_LOG_TDESC( "mus: [MUSUI ] ", iVideoFilePath );
+
+ delete iDialogPrompt;
+ iDialogPrompt = NULL;
+
+ TBuf<KMusFileNameMaxLength> buf;
+ TFileName videoFileName;
+ videoFileName += iVideoFileNamePlain;
+ videoFileName += KMusVideoFileNameExtension;
+ buf = videoFileName;
+
+ CDesCArrayFlat* savingTextsArray =
+ new ( ELeave ) CDesCArrayFlat( KMusStringSubstArrayGranularity );
+ CleanupStack::PushL( savingTextsArray );
+ //"File %0U saved to folder %1U"
+ //%0U = iVideoFileName
+ //%1U = iVideoFilePath
+ savingTextsArray->InsertL( 0, videoFileName );
+
+ if ( MultimediaSharingSettings::OperatorVariantSettingL() ==
+ MusSettingsKeys::EOperatorSpecific ) // For AT&T products
+ {
+ HBufC* folder = StringLoader::LoadLC( R_MUS_VIDEO_SAVE_FOLDER_NAME );
+ savingTextsArray->InsertL( 1, *folder );
+ CleanupStack::PopAndDestroy( folder );
+ }
+ else // Standard products
+ {
+ if ( iLocalizer->IsLocalized() )
+ {
+ savingTextsArray->InsertL( 1, iLocalizedVideoFilePath );
+ }
+ else
+ {
+ savingTextsArray->InsertL( 1, iVideoFilePath );
+ }
+ }
+
+ MUS_LOG_TDESC( "mus: [MUSUI ] filename:", savingTextsArray->MdcaPoint( 0 ) );
+ MUS_LOG_TDESC( "mus: [MUSUI ] path:", savingTextsArray->MdcaPoint( 1 ) );
+
+ iDialogPrompt = StringLoader::LoadL( R_MUS_VIEW_NOTE_VIDEO_SAVED,
+ *savingTextsArray );
+ CleanupStack::Pop( savingTextsArray );
+
+ MUS_LOG_TDESC( "mus: [MUSUI ] ", iDialogPrompt->Des() );
+
+ MusUiDialogUtil::ShowGlobalInformationDialogL( *iDialogPrompt );
+ MUS_LOG( "mus: [MUSUI ] <- CMusUiSendController::ShowVideoSavedDialogL" );
+ }
+
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CMusUiSendController::DeleteVideoL()
+ {
+ MUS_LOG( "mus: [MUSUI ] -> CMusUiSendController::DeleteVideoL" );
+ if ( iVideoFileName )
+ {
+ MusUiFileUtil::DeleteFileL( *iVideoFileName );
+ }
+ MUS_LOG( "mus: [MUSUI ] <- CMusUiSendController::DeleteVideoL" );
+ }
+
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CMusUiSendController::DeleteFileL()
+ {
+ MUS_LOG( "mus: [MUSUI ] -> CMusUiSendController::DeleteFileL" );
+ if ( iVideoFileName &&
+ MusUiFileUtil::FileExists( *iVideoFileName ) && !iVideoToBeSaved )
+ {
+ DeleteVideoL();
+ }
+ MUS_LOG( "mus: [MUSUI ] <- CMusUiSendController::DeleteFileL" );
+ }
+
+
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+CMusUiSendController::
+TWaitDialogCallback::TWaitDialogCallback( CMusUiSendController& aController )
+ : iController( aController )
+ {
+ }
+
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CMusUiSendController::
+TWaitDialogCallback::DialogDismissedL( TInt /*aButtonId*/ )
+ {
+ iController.StartInvitationL();
+ }
+
+// End of file
+