diff -r 17f382c040b1 -r 518105d52e45 videoplayback/videoplaybackview/controlsrc/videoplaybackcontrolscontroller.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/videoplayback/videoplaybackview/controlsrc/videoplaybackcontrolscontroller.cpp Thu Jul 08 13:05:19 2010 +0300 @@ -0,0 +1,1586 @@ +/* +* Copyright (c) 2009 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: Implementation of VideoPlaybackControlsController +* +*/ + +// Version : %version: da1mmcf#46 % + + + +// INCLUDE FILES +#include +#include +#include +#include + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "mpxvideoviewwrapper.h" +#include "videobaseplaybackview.h" +#include "videoplaybackcontrolbar.h" +#include "videoplaybackcontrolpolicy.h" +#include "videoplaybackdocumentloader.h" +#include "videoplaybackviewfiledetails.h" +#include "videoplaybackstatuspanecontrol.h" +#include "videoplaybackfiledetailswidget.h" +#include "videoplaybackfullscreencontrol.h" +#include "videoplaybackcontrolscontroller.h" +#include "videoplaybackcontrolconfiguration.h" +#include "videoplaybackdetailsplaybackwindow.h" +#include "videoservices.h" + + +// ================= MEMBER FUNCTIONS ============================================================== + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::VideoPlaybackControlsController() +// ------------------------------------------------------------------------------------------------- +// +VideoPlaybackControlsController::VideoPlaybackControlsController( + VideoBasePlaybackView *view, + CMPXVideoViewWrapper *viewWrapper, + VideoPlaybackViewFileDetails *details ) + : mView( view ) + , mViewWrapper( viewWrapper ) + , mFileDetails( details ) + , mControlsPolicy( NULL ) + , mControlsConfig( NULL ) + , mControlsTimer( NULL ) + , mRNLogoTimer( NULL ) + , mLoader( NULL ) + , mVolumeControl( NULL ) + , mThumbnailManager( NULL ) + , mVideoServices( 0 ) + , mViewTransitionIsGoingOn( false ) + , mIsAttachOperation( false ) + , mThumbNailState( EThumbNailEmpty ) + , mState( EPbStateNotInitialised ) + , mViewMode( EFullScreenView ) +{ + MPX_ENTER_EXIT(_L("VideoPlaybackControlsController::VideoPlaybackControlsController()")); + + initializeController(); +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::initializeController() +// ------------------------------------------------------------------------------------------------- +// +void VideoPlaybackControlsController::initializeController() +{ + MPX_ENTER_EXIT(_L("VideoPlaybackControlsController::initializeController()")); + + mOrientation = hbInstance->allMainWindows()[0]->orientation(); + bool ok = connect( hbInstance->allMainWindows()[0], SIGNAL( orientationChanged( Qt::Orientation ) ), + this, SLOT( handleOrientationChanged( Qt::Orientation ) ) ); + + MPX_DEBUG( + _L("VideoPlaybackControlsController::initializeController() orientation = %d, ok =%d"), + mOrientation, ok ); + + setParent( mView ); + + mView->hideItems( Hb::AllItems ); + + // + // Create layout loader + // + ok = false; + mLoader = new VideoPlaybackDocumentLoader( this ); + mLoader->load( KPLAYBACKVIEW_DOCML, &ok ); + + if ( ok ) + { + QGraphicsWidget *widget = mLoader->findWidget( QString( "content" ) ); + mView->setWidget( widget ); + } + else + { + MPX_DEBUG( + _L("VideoPlaybackControlsController::initializeController()- can't find xml")); + + // + // Can't find xml for layout. Delete mLoader + // + delete mLoader; + mLoader = NULL; + } + + mFileDetails->mRNFormat = realFormat( mFileDetails->mClipName ); + + // + // Controls dismissing timer + // + mControlsTimer = new QTimer( this ); + mControlsTimer->setInterval( KControlsTimeOut ); + mControlsTimer->setSingleShot( false ); + connect( mControlsTimer, SIGNAL( timeout() ), this, SLOT( hideAllControls() ) ); + + mControlsPolicy = new VideoPlaybackControlPolicy(); + + mControlsConfig = new VideoPlaybackControlConfiguration( this ); + connect( mControlsConfig, SIGNAL( controlListUpdated() ), this, SLOT( controlsListUpdated() ) ); + mControlsConfig->createControlList(); + + // + // Create volume popup control + // + mVolumeControl = new HbVolumeSliderPopup(); + mVolumeControl->setVisible( false ); + mVolumeControl->setTimeout( KControlsTimeOut ); + mVolumeControl->setTickPosition( Hb::NoSliderTicks ); + mVolumeControl->setRange( KPbPlaybackVolumeLevelMin, KPbPlaybackVolumeLevelMax ); + + // + // grab tap gesture + // + mView->grabGesture( Qt::TapGesture ); + connect( mView, SIGNAL( tappedOnScreen() ), this, SLOT( handleTappedOnScreen() ) ); + + // + // if videoplayback is in service mode, create a videoservices instance + // + if ( XQServiceUtil::isService() && ! mVideoServices ) + { + // + // obtain VideoServices instance + // + mVideoServices = VideoServices::instance(); + + // + // allow 'attach' operation only for non-streaming media clips + // + if ( mVideoServices && mFileDetails->mPlaybackMode == EMPXVideoLocal ) + { + // + // determine if this is 'attach' operation + // + mIsAttachOperation = ( mVideoServices->currentService() == VideoServices::EUriFetcher ); + + if ( mIsAttachOperation ) + { + // + // connect signal filePath() to videoservices slot itemSelected() + // + connect( this, SIGNAL( attachVideoPath( const QString& ) ), + mVideoServices, SLOT( itemSelected( const QString& ) ) ); + } + } + } +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::~VideoPlaybackControlsController +// ------------------------------------------------------------------------------------------------- +// +VideoPlaybackControlsController::~VideoPlaybackControlsController() +{ + MPX_ENTER_EXIT(_L("VideoPlaybackControlsController::~VideoPlaybackControlsController()")); + + mView->ungrabGesture( Qt::TapGesture ); + disconnect( mView, SIGNAL( tappedOnScreen() ), this, SLOT( handleTappedOnScreen() ) ); + + if ( mFileDetails->mMultiItemPlaylist && mFileDetails->mSeekable ) + { + mView->ungrabGesture( Qt::PanGesture ); + + disconnect( mView, SIGNAL( pannedToRight() ), this, SLOT( skipToNextVideoItem() ) ); + disconnect( mView, SIGNAL( pannedToLeft() ), this, SLOT( skipToPreviousVideoItem() ) ); + } + + disconnect( mControlsConfig, SIGNAL( controlListUpdated() ), this, SLOT( controlsListUpdated() ) ); + disconnect( mControlsTimer, SIGNAL( timeout() ), this, SLOT( hideAllControls() ) ); + disconnect( hbInstance->allMainWindows()[0], SIGNAL( orientationChanged( Qt::Orientation ) ), + this, SLOT( handleOrientationChanged( Qt::Orientation ) ) ); + + mView->setWidget( NULL ); + + mControls.clear(); + + if ( mControlsTimer ) + { + delete mControlsTimer; + mControlsTimer = NULL; + } + + if ( mRNLogoTimer ) + { + disconnect( mRNLogoTimer, SIGNAL( timeout() ), this, SLOT( handleRNLogoTimeout() ) ); + + delete mRNLogoTimer; + mRNLogoTimer = NULL; + } + + if ( mControlsPolicy ) + { + delete mControlsPolicy; + mControlsPolicy = NULL; + } + + if ( mControlsConfig ) + { + delete mControlsConfig; + mControlsConfig = NULL; + } + + if ( mLoader ) + { + delete mLoader; + mLoader = NULL; + } + + if ( mThumbnailManager ) + { + delete mThumbnailManager; + mThumbnailManager = NULL; + } + + if ( mVolumeControl ) + { + delete mVolumeControl; + mVolumeControl = NULL; + } + + if ( mIsAttachOperation ) + { + // + // disable connection for 'attach' operation + // + disconnect( this, SIGNAL( attachVideoPath( const QString& ) ), + mVideoServices, SLOT( itemSelected( const QString& ) ) ); + } + + if ( mVideoServices ) + { + // + // decrease videoservices instance count + // + mVideoServices->decreaseReferenceCount(); + mVideoServices = 0; + } +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::addFileDetails() +// ------------------------------------------------------------------------------------------------- +// +void VideoPlaybackControlsController::addFileDetails( + VideoPlaybackViewFileDetails* details ) +{ + MPX_ENTER_EXIT(_L("VideoPlaybackControlsController::addFileDetails")); + + mFileDetails = details; + + mFileDetails->mRNFormat = realFormat( mFileDetails->mClipName ); + + mControlsConfig->updateControlsWithFileDetails(); + + // + // for audio-only clips and tv-out, default view is flip view + // + if ( ! details->mVideoEnabled ) + { + changeViewMode( EAudioOnlyView, false ); + } + + if ( details->mTvOutConnected ) + { + handleEvent( EControlCmdTvOutConnected ); + } + + // + // Dimmed the volume control if it is video only + // + if ( ! mFileDetails->mAudioEnabled ) + { + mVolumeControl->setValue( 0 ); + mVolumeControl->setEnabled( false ); + } + + // + // grab pan gesture for playlist and seekable(skippable) clip + // + if ( mFileDetails->mMultiItemPlaylist && mFileDetails->mSeekable ) + { + mView->grabGesture( Qt::PanGesture ); + connect( mView, SIGNAL( pannedToRight() ), this, SLOT( skipToPreviousVideoItem() ) ); + connect( mView, SIGNAL( pannedToLeft() ), this, SLOT( skipToNextVideoItem() ) ); + } +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::handleEvent +// ------------------------------------------------------------------------------------------------- +// +void VideoPlaybackControlsController::handleEvent( + TVideoPlaybackControlCommandIds event, int value ) +{ + MPX_DEBUG(_L("VideoPlaybackControlsController::handleEvent(%d)"), event); + + switch ( event ) + { + case EControlCmdSetPosition: + { + MPX_DEBUG(_L(" [EControlCmdSetPosition [%d]]"), value ); + + positionChanged( (qreal)value / (qreal)KPbMilliMultiplier); + break; + } + case EControlCmdSetDuration: + { + MPX_DEBUG(_L(" [EControlCmdSetDuration [%d]]"), value ); + + durationChanged( (qreal)value / (qreal)KPbMilliMultiplier ); + break; + } + case EControlCmdStateChanged: + { + MPX_DEBUG(_L(" [EControlCmdStateChanged]")); + + handleStateChange( (TMPXPlaybackState)value ); + break; + } + case EControlCmdSetVolume: + { + MPX_DEBUG(_L(" [EControlCmdSetVolume [%d]]"), value ); + + volumeChanged( value ); + break; + } + case EControlCmdSetAspectRatio: + { + MPX_DEBUG(_L(" [EControlCmdSetAspectRatio %d]"), value ); + + aspectRatioChanged( value ); + + break; + } + case EControlCmdSetDownloadSize: + { + MPX_DEBUG(_L(" [EControlCmdSetDownloadSize [%d]]"), value ); + setDownloadSize( value ); + break; + } + case EControlCmdDownloadUpdated: + { + MPX_DEBUG(_L(" [EControlCmdDownloadUpdated [%d]]"), value ); + updateDownloadPosition( value ); + break; + } + case EControlCmdDownloadComplete: + { + MPX_DEBUG(_L(" [EControlCmdDownloadComplete [%d]]"), value); + updateDownloadPosition( value ); + break; + } + case EControlCmdSetDownloadPaused: + case EControlCmdClearDownloadPaused: + { + mControlsConfig->updateControlList( event ); + break; + } + case EControlCmdTvOutConnected: + { + MPX_DEBUG(_L(" [EControlCmdTvOutConnected]")); + + handleTvOutEvent( true, event ); + break; + } + case EControlCmdTvOutDisconnected: + { + MPX_DEBUG(_L(" [EControlCmdTvOutDisConnected]")); + + handleTvOutEvent( false, event ); + break; + } + case EControlCmdHandleErrors: + { + MPX_DEBUG(_L(" [EControlCmdHandleErrors]")); + + handleErrors(); + + break; + } + case EControlCmdShowVolumeControls: + { + MPX_DEBUG(_L(" [EControlCmdShowVolumeControls]")); + + showVolumeControls(); + break; + } + } +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::handleStateChange +// ------------------------------------------------------------------------------------------------- +// +void VideoPlaybackControlsController::handleStateChange( TMPXPlaybackState newState ) +{ + MPX_ENTER_EXIT(_L("VideoPlaybackControlsController::handleStateChange()"), + _L("new state = %d"), newState ); + + // + // Somehow EPbStatePlaying, EPbStatePaused gets called twice continously + // + if ( newState != mState ) + { + mState = newState; + + switch ( newState ) + { + case EPbStatePlaying: + case EPbStateInitialising: + case EPbStateBuffering: + case EPbStatePaused: + case EPbStateNotInitialised: + { + // + // Show all the controls + // + showControls(); + + updateState(); + + break; + } + default: + { + break; + } + } + } +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::controlsListUpdated() +// ------------------------------------------------------------------------------------------------- +// +void VideoPlaybackControlsController::controlsListUpdated() +{ + MPX_ENTER_EXIT(_L("VideoPlaybackControlsController::controlsListUpdated()")); + + hideAllControls(); + + QList& updatedList = mControlsConfig->controlList(); + + QList myList = updatedList; + + int controlCount = mControls.count(); + + int i = 0 ; + int index = KErrNotFound; + + + for ( int iCnt = 0 ; iCnt < controlCount ; iCnt++ ) + { + index = myList.indexOf( mControls[i]->controlIndex() ); + + if ( index == KErrNotFound ) + { + // + // Delete control since it doesn't exist in new list + // + mControls.removeAt( i ); + } + else + { + // + // Control exists in new list. + // Update the policy property based on file details and view mode to the controls + // + TUint properties = 0; + mControlsPolicy->setControlProperties( + mControls[i]->controlIndex(), properties, mFileDetails, mViewMode ); + mControls[i]->updateControlProperties( properties ); + + // + // Control exists in new list. + // + myList.removeAt( index ); + i++; + } + } + + // + // The updated list will contain added controls only + // + for ( int j = 0 ; j < myList.count() ; j++ ) + { + appendControl( myList[j] ); + } + + for ( int i = 0 ; i < mControls.count() ; i++ ) + { + mControls[i]->updateControlsWithFileDetails( mFileDetails ); + } + + showControls(); +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::appendControl() +// ------------------------------------------------------------------------------------------------- +// +void VideoPlaybackControlsController::appendControl( TVideoPlaybackControls controlIndex ) +{ + MPX_ENTER_EXIT(_L("VideoPlaybackControlsController::appendControl()"), + _L("control index = %d"), controlIndex ); + + TUint properties = 0; + + mControlsPolicy->setControlProperties( controlIndex, properties, mFileDetails, mViewMode ); + VideoPlaybackFullScreenControl* control; + + switch ( controlIndex ) + { + case EBufferingAnimation: + { + // + // Load animation icons + // + QString animationName = ":/videoplaybackview/animations/"; + + if ( mFileDetails->mRNFormat ) + { + animationName.append( "rn_preroll_anim.axml" ); + } + else + { + animationName.append( "generic_preroll_anim.axml" ); + } + + HbIconAnimationManager* manager = HbIconAnimationManager::global(); + bool ok = manager->addDefinitionFile( animationName ); + + MPX_DEBUG(_L(" EBufferingAnimation add animation definition ok = %d"), ok); + + // + // Buffering animation icon + // + QGraphicsWidget *widget = mLoader->findWidget( QString( "bufferingIcon" ) ); + HbLabel *bufferingAnim = qobject_cast( widget ); + + control = new VideoPlaybackFullScreenControl( this, + controlIndex, + bufferingAnim, + properties ); + mControls.append( control ); + + break; + } + case EStatusPane: + { + // + // Status key (signal + title + back key) + // + control = new VideoPlaybackStatusPaneControl( this, + controlIndex, + NULL, + properties ); + mControls.append( control ); + + break; + } + case EControlBar: + { + // + // Button bar + // + QGraphicsWidget *widget = mLoader->findWidget( QString( "controlBarLayout" ) ); + VideoPlaybackControlBar *controlBar = + qobject_cast( widget ); + controlBar->initialize(); + + control = new VideoPlaybackFullScreenControl( this, + controlIndex, + controlBar, + properties ); + mControls.append( control ); + + break; + } + case EFileDetailsWidget: + { + QGraphicsWidget *widget = mLoader->findWidget( QString( "fileDetailsLayout" ) ); + VideoPlaybackFileDetailsWidget *fileDetails = + qobject_cast( widget ); + + control = new VideoPlaybackFullScreenControl( this, + controlIndex, + fileDetails, + properties ); + + mControls.append( control ); + break; + } + case EIndicatorBitmap: + { + QGraphicsWidget *widget = mLoader->findWidget( QString( "bitmapLayout" ) ); + HbWidget *bitmapWidget = qobject_cast( widget ); + + setDefaultBitmap(); + control = new VideoPlaybackFullScreenControl( this, + controlIndex, + bitmapWidget, + properties ); + mControls.append( control ); + + break; + } + case ERealLogoBitmap: + { + QGraphicsWidget *widget = mLoader->findWidget( QString( "rnLogoBitmap" ) ); + HbWidget *bitmapWidget = qobject_cast( widget ); + + control = new VideoPlaybackFullScreenControl( this, + controlIndex, + bitmapWidget, + properties ); + mControls.append( control ); + + connect( bitmapWidget, SIGNAL( visibleChanged() ), + this, SLOT( handleRNLogoVisibleChanged() ) ); + + break; + } + case EDetailsViewPlaybackWindow: + { + QGraphicsWidget *widget = mLoader->findWidget( QString( "detailsPlaybackWindow" ) ); + VideoPlaybackDetailsPlaybackWindow *detailsPlaybackWindow = + qobject_cast( widget ); + detailsPlaybackWindow->initialize(); + + control = new VideoPlaybackFullScreenControl( this, + controlIndex, + detailsPlaybackWindow, + properties ); + mControls.append( control ); + + break; + } + } +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::handleTappedOnScreen() +// ------------------------------------------------------------------------------------------------- +// +void VideoPlaybackControlsController::handleTappedOnScreen() +{ + MPX_ENTER_EXIT(_L("VideoPlaybackControlsController::handleTappedOnScreen()")); + + // + // If we are in full screen view, toggle the visibility when playing and paused + // If we are in details view, issue playpause + // If we are in audio only view, ignore + // + switch( mViewMode ) + { + case EFullScreenView: + { + if ( mState == EPbStatePlaying || mState == EPbStatePaused ) + { + if ( isVisible() ) + { + // + // If the volume control is visible, hide it + // + if ( mVolumeControl->isVisible() ) + { + mVolumeControl->setVisible( false ); + } + + hideAllControls(); + } + else + { + showControls(); + } + } + + break; + } + case EDetailsView: + { + // + // ignore the tap for 'Pause' action for non-pausable stream in + // 'Details' view during 'Playing' state + // + if ( mState != EPbStatePlaying || mFileDetails->mPausableStream ) + { + handleCommand( EMPXPbvCmdPlayPause ); + } + + break; + } + } +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::resetDisappearingTimers() +// ------------------------------------------------------------------------------------------------- +// +void VideoPlaybackControlsController::resetDisappearingTimers( TTimerAction timerAction ) +{ + MPX_DEBUG(_L("VideoPlaybackControlsController::resetDisappearingTimers()")); + + if ( mControlsTimer->isActive() ) + { + mControlsTimer->stop(); + } + + // + // Do not start the time for DetailsView and AudioOnlyView + // + if ( timerAction == ETimerReset && + mState == EPbStatePlaying && + mViewMode == EFullScreenView ) + { + MPX_DEBUG(_L(" Starting Controls Timer")); + + mControlsTimer->start(); + } +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::hideAllControls() +// ------------------------------------------------------------------------------------------------- +// +void VideoPlaybackControlsController::hideAllControls() +{ + MPX_DEBUG(_L("VideoPlaybackControlsController::hideControls()")); + + resetDisappearingTimers( ETimerCancel ); + + for ( int i = 0 ; i < mControls.count() ; i++ ) + { + mControls[i]->setVisible( false ); + } +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::showControls() +// ------------------------------------------------------------------------------------------------- +// +void VideoPlaybackControlsController::showControls() +{ + MPX_DEBUG(_L("VideoPlaybackControlsController::showControls()")); + + resetDisappearingTimers( ETimerReset ); + + if ( ! mViewTransitionIsGoingOn && mOrientation == Qt::Horizontal ) + { + for ( int i = 0 ; i < mControls.count() ; i++ ) + { + mControls[i]->setVisibility( mState ); + } + } +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::isVisible() +// ------------------------------------------------------------------------------------------------- +// +bool VideoPlaybackControlsController::isVisible() +{ + bool visible = false; + + for ( int i = 0 ; i < mControls.count() ; i++ ) + { + if ( mControls[i]->controlIndex() == EControlBar ) + { + if ( mControls[i]->isVisible() ) + { + visible = true; + } + + break; + } + } + + MPX_DEBUG(_L("VideoPlaybackControlsController::isVisible() [%d]"), visible); + + return visible; +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::handleCommand() +// ------------------------------------------------------------------------------------------------- +// +void VideoPlaybackControlsController::handleCommand( + TMPXVideoPlaybackViewCommandIds command, int value ) +{ + MPX_DEBUG(_L("VideoPlaybackControlsController::handleCommand(%d)"), command); + + switch( command ) + { + case EMPXPbvCmdSetPosition: + { + TRAP_IGNORE( mViewWrapper->SetPropertyL( EPbPropertyPosition, + value * KPbMilliMultiplier ) ); + break; + } + case EMPXPbvCmdSetVolume: + { + TRAP_IGNORE( mViewWrapper->SetPropertyL( EPbPropertyVolume, value ) ); + break; + } + default: + { + TRAP_IGNORE( mViewWrapper->HandleCommandL( command ) ); + break; + } + } +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::volumeChanged() +// ------------------------------------------------------------------------------------------------- +// +void VideoPlaybackControlsController::volumeChanged( int volume ) +{ + MPX_DEBUG(_L("VideoPlaybackControlsController::volumeChanged() [%d]"), volume); + + if ( mVolumeControl ) + { + mVolumeControl->setValue( volume ); + } +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::showVolumeControls() +// ------------------------------------------------------------------------------------------------- +// +void VideoPlaybackControlsController::showVolumeControls() +{ + MPX_DEBUG(_L("VideoPlaybackControlsController::showVolumeControls()")); + + if ( mVolumeControl ) + { + mVolumeControl->setVisible( true ); + } +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::durationChanged() +// ------------------------------------------------------------------------------------------------- +// +void VideoPlaybackControlsController::durationChanged( int duration ) +{ + MPX_DEBUG(_L("VideoPlaybackControlsController::durationChanged() [%d]"), duration); + + for ( int i = 0 ; i < mControls.count() ; i++ ) + { + if ( mControls[i]->durationChanged( duration ) ) + { + break; + } + } +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::positionChanged() +// ------------------------------------------------------------------------------------------------- +// +void VideoPlaybackControlsController::positionChanged( int position ) +{ + MPX_DEBUG(_L("VideoPlaybackControlsController::positionChanged() [%d]"), position); + + for ( int i = 0 ; i < mControls.count() ; i++ ) + { + if ( mControls[i]->positionChanged( position ) ) + { + break; + } + } +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::aspectRatioChanged() +// ------------------------------------------------------------------------------------------------- +// +void VideoPlaybackControlsController::aspectRatioChanged( int aspectRatio ) +{ + MPX_DEBUG(_L("CMPXVideoPlaybackControlsController::aspectRatioChanged() [%d]"), aspectRatio); + + for ( int i = 0 ; i < mControls.count() ; i++ ) + { + if ( mControls[i]->aspectRatioChanged( aspectRatio ) ) + { + break; + } + } +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::updateState() +// ------------------------------------------------------------------------------------------------- +// +void VideoPlaybackControlsController::updateState() +{ + MPX_DEBUG(_L("VideoPlaybackControlsController::updateState() [%d]"), mState); + + for ( int i = 0 ; i < mControls.count() ; i++ ) + { + mControls[i]->updateState( mState ); + } +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::realFormat() +// ------------------------------------------------------------------------------------------------- +// +bool VideoPlaybackControlsController::realFormat( QString filename ) +{ + bool realFormat = false; + + if ( !filename.isNull() && !filename.isEmpty() ) + { + if ( mFileDetails->mPlaybackMode == EMPXVideoStreaming || + mFileDetails->mPlaybackMode == EMPXVideoLiveStreaming ) + { + TBufC<255> file(filename.utf16()); + realFormat = realFormatForStreaming( file ); + } + else + { + realFormat = realFormatForLocal(); + } + } + + MPX_DEBUG(_L("VideoPlaybackControlsController::realFormat() [%d]"), realFormat); + + return realFormat; +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::realFormatForStreaming() +// ------------------------------------------------------------------------------------------------- +// +bool VideoPlaybackControlsController::realFormatForStreaming( const TDesC& des ) +{ + bool realFormat = false; + TParse filePath; + + _LIT(KMPXRMEXT, ".R" ); + + int err = filePath.Set( des, NULL, NULL ); + + // + // It is valid to have a "\" character in a url, but parsing fails, + // switch these characters to "/" for the local string and try parsing again. + // + if ( err == KErrBadName ) + { + int backsashPos = des.LocateF('\\'); + + if( backsashPos != KErrNotFound ) + { + HBufC* fileName = NULL; + + TRAP( err, fileName = des.AllocL() ); + + if ( err == KErrNone ) + { + int count( fileName->Des().Length() ); + + for ( int j = backsashPos ; j < count; ++j ) + { + if ( fileName->Des()[j]== '\\' ) + { + fileName->Des()[j]='/'; + } + } + err = filePath.Set( fileName->Des(), NULL, NULL ); + } + + if ( fileName ) + { + delete fileName; + fileName = NULL; + } + } + } + + if ( err == KErrNone ) + { + // + // The requirement to support arguments with the extension in streaming links + // for-ex: /video.3gp?start=10&end=40 will have to supported + // as well. So just by doing p.Ext() would retrieve all the string + // after "." so by doing a Left(2) would retrieve only + // .3g or .rm and so on. This would help better + // interpret the extension and decide the branding accordingly + // + filePath.Set( filePath.NameAndExt(), NULL, NULL ); + TPtrC extension = filePath.Ext().Left( 2 ); + + TBuf<2> buf; + buf.Format( extension ); + buf.UpperCase(); + + // RealMedia Branding + if ( ! buf.Compare( KMPXRMEXT ) ) + { + realFormat = true; + } + } + + MPX_DEBUG(_L("VideoPlaybackControlsController::realFormatForStreaming()[%d]"), realFormat); + + return realFormat; +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::realFormatForLocal() +// ------------------------------------------------------------------------------------------------- +// +bool VideoPlaybackControlsController::realFormatForLocal() +{ + bool realFormat = false; + + QString real( "real" ); + QString rn( "rn" ); + + if ( mFileDetails->mMimeType.contains( real, Qt::CaseInsensitive ) || + mFileDetails->mMimeType.contains( rn, Qt::CaseInsensitive ) ) + { + realFormat = true; + } + + MPX_DEBUG(_L("VideoPlaybackControlsController::realFormatForLocal() [%d]"), realFormat); + + return realFormat; +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::setDownloadSize() +// ------------------------------------------------------------------------------------------------- +// +void VideoPlaybackControlsController::setDownloadSize( int size ) +{ + MPX_DEBUG(_L("VideoPlaybackControlsController::setDownloadSize() [%d]"), size); + + for ( int i = 0 ; i < mControls.count() ; i++ ) + { + if ( mControls[i]->setDownloadSize( size ) ) + { + break; + } + } +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::updateDownloadPosition() +// ------------------------------------------------------------------------------------------------- +// +void VideoPlaybackControlsController::updateDownloadPosition( int size ) +{ + MPX_DEBUG(_L("VideoPlaybackControlsController::updateDownloadPosition() [%d]"), size); + + for ( int i = 0 ; i < mControls.count() ; i++ ) + { + if ( mControls[i]->updateDownloadPosition( size ) ) + { + break; + } + } +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::handleErrors +// ------------------------------------------------------------------------------------------------- +// +void VideoPlaybackControlsController::handleErrors() +{ + MPX_ENTER_EXIT(_L("VideoPlaybackControlsController::handleErrors()"), + _L("mState = %d"), mState ); +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::isSoftKeyVisible() +// ------------------------------------------------------------------------------------------------- +// +bool VideoPlaybackControlsController::isSoftKeyVisible() +{ + bool visible = false; + + for ( int i = 0 ; i < mControls.count() ; i++ ) + { + if ( mControls[i]->controlIndex() == EStatusPane ) + { + if ( mControls[i]->isVisible() ) + { + visible = true; + } + + break; + } + } + + MPX_DEBUG(_L("VideoPlaybackControlsController::isSoftKeyVisible() [%d]"), visible); + + return visible; +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::handleTvOutEvent +// ------------------------------------------------------------------------------------------------- +// +void VideoPlaybackControlsController::handleTvOutEvent( + bool connected, TVideoPlaybackControlCommandIds event ) +{ + Q_UNUSED( event ); + + MPX_DEBUG(_L("VideoPlaybackControlsController::handleTvOutEvent()")); + + mFileDetails->mTvOutConnected = connected; + + setDefaultBitmap(); + + if ( mFileDetails->mTvOutConnected ) + { + generateThumbNail(); + } + + // + // Change the view. + // If Tv-out is connected, go to AudioOnlyView. + // If not, go back to default view. + // + TPlaybackViewMode viewMode = EFullScreenView; + + if ( mFileDetails->mTvOutConnected || ! mFileDetails->mVideoEnabled ) + { + viewMode = EAudioOnlyView; + } + + changeViewMode( viewMode, false ); +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::changeViewMode +// ------------------------------------------------------------------------------------------------- +// +void VideoPlaybackControlsController::changeViewMode( + TPlaybackViewMode viewMode, bool transitionEffect ) +{ + MPX_DEBUG(_L("VideoPlaybackControlsController::changeViewMode( %d, %d )"), + viewMode, transitionEffect ); + + if ( viewMode != mViewMode ) + { + switch ( viewMode ) + { + case EFullScreenView: + case EDetailsView: + { + if ( mFileDetails->mVideoEnabled && ! mFileDetails->mTvOutConnected ) + { + mViewMode = viewMode; + + // + // Hack to clean up the screen before transition. We may not need it in NGA env + // + hideAllControls(); + + updateVideoRect( transitionEffect ); + } + + break; + } + case EAudioOnlyView: + { + if ( ! mFileDetails->mVideoEnabled || mFileDetails->mTvOutConnected ) + { + mViewMode = viewMode; + + mControlsConfig->updateControlList( EControlCmdAudionOnlyViewOpened ); + } + + break; + } + default: + { + break; + } + } + } +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::updateVideoRectDone +// ------------------------------------------------------------------------------------------------- +// +void VideoPlaybackControlsController::updateVideoRectDone() +{ + MPX_DEBUG(_L("VideoPlaybackControlsController::updateVideoRectDone()")); + + mViewTransitionIsGoingOn = false; + + TVideoPlaybackControlCommandIds event = EControlCmdFullScreenViewOpened; + + if ( mViewMode == EDetailsView ) + { + event = EControlCmdDetailsViewOpened; + } + + mControlsConfig->updateControlList( event ); +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::skipToPreviousVideoItem +// ------------------------------------------------------------------------------------------------- +// +void VideoPlaybackControlsController::skipToPreviousVideoItem() +{ + MPX_DEBUG(_L("VideoPlaybackControlsController::skipToPreviousVideoItem()")); + + if ( mViewMode == EFullScreenView ) + { + handleCommand( EMPXPbvCmdPreviousListItem ); + } +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::skipToNextVideoItem +// ------------------------------------------------------------------------------------------------- +// +void VideoPlaybackControlsController::skipToNextVideoItem() +{ + MPX_DEBUG(_L("VideoPlaybackControlsController::skipToNextVideoItem()")); + + if ( mViewMode == EFullScreenView ) + { + handleCommand( EMPXPbvCmdNextListItem ); + } +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::updateVideoRect() +// ------------------------------------------------------------------------------------------------- +// +void VideoPlaybackControlsController::updateVideoRect( bool transitionEffect ) +{ + MPX_DEBUG(_L("VideoPlaybackControlsController::updateVideoRect( %d )"), + transitionEffect ); + + if ( mFileDetails->mVideoEnabled && ! mFileDetails->mTvOutConnected ) + { + mViewTransitionIsGoingOn = true; + + QRectF rect; + + MPX_DEBUG(_L("VideoPlaybackControlsController::updateVideoRect() : mViewMode = %d )"), + mViewMode ); + + if ( mViewMode == EDetailsView ) + { + QGraphicsWidget *parent = mLoader->findWidget( QString( "detailsPlaybackWindow" ) ); + QGraphicsWidget *child = mLoader->findWidget( QString( "small_transparentWindow" ) ); + + rect = parent->mapRectToScene( child->geometry() ); + } + else if ( mViewMode == EFullScreenView ) + { + QGraphicsWidget *widget = mLoader->findWidget( QString( "content" ) ); + rect = widget->geometry(); + } + + mViewWrapper->UpdateVideoRect( + rect.x(), rect.y(), rect.width(), rect.height(), transitionEffect ); + } +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::setDefaultBitmap() +// ------------------------------------------------------------------------------------------------- +// +void VideoPlaybackControlsController::setDefaultBitmap() +{ + MPX_DEBUG(_L("VideoPlaybackControlsController::setDefaultBitmap()")); + + // + // set specific bitmaps for audio only and tv out cases + // If we already requested a thumbnail, we will set the thumbnail after we receive the thumbnail + // + if ( mLoader && mThumbNailState != EThumbNailRequsted ) + { + QGraphicsWidget *tvOutBitmap = mLoader->findWidget( "tvOutBitmap" ); + tvOutBitmap->setVisible( false ); + + QGraphicsWidget *realAudioOnlyBitmap = mLoader->findWidget( "realAudioOnlyBitmap" ); + realAudioOnlyBitmap->setVisible( false ); + + QGraphicsWidget *partialAudioOnlyBitmap = mLoader->findWidget( "partialAudioOnlyBitmap" ); + partialAudioOnlyBitmap->setVisible( false ); + + QGraphicsWidget *audioOnlyBitmap = mLoader->findWidget( "audioOnlyBitmap" ); + audioOnlyBitmap->setVisible( false ); + + if ( mFileDetails->mTvOutConnected ) + { + tvOutBitmap->setVisible( true ); + } + else if ( mFileDetails->mRNFormat ) + { + realAudioOnlyBitmap->setVisible( true ); + } + else if ( mFileDetails->mPartialPlayback ) + { + partialAudioOnlyBitmap->setVisible( true ); + } + else + { + audioOnlyBitmap->setVisible( true ); + } + } +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::generateThumbNail() +// ------------------------------------------------------------------------------------------------- +// +void VideoPlaybackControlsController::generateThumbNail() +{ + MPX_DEBUG(_L("VideoPlaybackControlsController::generateThumbNail()")); + + // + // Generate thumbnail if it is local playback + // + if ( mFileDetails->mPlaybackMode == EMPXVideoLocal ) + { + if ( mThumbNailState == EThumbNailEmpty ) + { + mThumbnailManager = new ThumbnailManager(); ; + + mThumbnailManager->setThumbnailSize( ThumbnailManager::ThumbnailLarge ); + mThumbnailManager->setQualityPreference( ThumbnailManager::OptimizeForPerformance ); + + if ( connect( mThumbnailManager, SIGNAL( thumbnailReady( QPixmap , void * , int , int ) ), + this, SLOT( handleThumbnailReady( QPixmap , void * , int , int ) ) ) ) + { + mThumbnailManager->getThumbnail( mFileDetails->mClipName ); + mThumbNailState = EThumbNailRequsted; + } + } + } + else + { + mThumbNailState = EThumbNailNotAvailable; + } +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::handleThumbnailReady() +// ------------------------------------------------------------------------------------------------- +// +void VideoPlaybackControlsController::handleThumbnailReady( + QPixmap tnData, void *internal , int id, int error ) +{ + Q_UNUSED( internal ); + Q_UNUSED( id ); + + if( ! error && mLoader ) + { + QGraphicsWidget *tvOutBitmap = mLoader->findWidget( "tvOutBitmap" ); + HbLabel *tvOutLabel = qobject_cast( tvOutBitmap ); + + QIcon *qicon = new QIcon( tnData ); + + HbIcon *hbIcon = new HbIcon( *qicon ); + hbIcon->setSize( tvOutBitmap->size() ); + tvOutLabel->setIcon( *hbIcon ); + + mThumbNailState = EThumbNailSet; + } + else + { + mThumbNailState = EThumbNailNotAvailable; + } + + setDefaultBitmap(); + + disconnect( mThumbnailManager, SIGNAL( thumbnailReady( QPixmap , void * , int , int ) ), + this, SLOT( handleThumbnailReady( QPixmap , void * , int , int ) ) ); +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::attachVideo() +// ------------------------------------------------------------------------------------------------- +// +void VideoPlaybackControlsController::attachVideo() +{ + MPX_ENTER_EXIT(_L("VideoPlaybackControlsController::attachVideo()"), + _L("file = %s"), mFileDetails->mClipName.data() ); + + // + // close playback view + // + mView->closePlaybackView(); + + // + // emit signal to launch videoservices itemSelected() slot + // + emit( attachVideoPath( mFileDetails->mClipName ) ); + +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::sendVideo() +// ------------------------------------------------------------------------------------------------- +// +void VideoPlaybackControlsController::sendVideo() +{ + MPX_ENTER_EXIT(_L("VideoPlaybackControlsController::sendVideo()"), + _L("file = %s"), mFileDetails->mClipName.data() ); + + // + // pause playback + // + handleCommand( EMPXPbvCmdPause ); + + // + // send video to shareUI + // + ShareUi dlg; + QStringList fileList; + fileList.append( mFileDetails->mClipName ); + dlg.send( fileList, true ); +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::handleRNLogoVisibleChanged() +// ------------------------------------------------------------------------------------------------- +// +void VideoPlaybackControlsController::handleRNLogoVisibleChanged() +{ + MPX_ENTER_EXIT(_L("VideoPlaybackControlsController::handleRNLogoVisibleChanged()")); + + QGraphicsWidget *widget = mLoader->findWidget( QString( "rnLogoBitmap" ) ); + + if ( widget->isVisible() ) + { + if ( mRNLogoTimer ) + { + delete mRNLogoTimer; + mRNLogoTimer = NULL; + } + + mRNLogoTimer = new QTimer( this ); + mRNLogoTimer->setInterval( KRNLogoTimeOut ); + mRNLogoTimer->setSingleShot( true ); + connect( mRNLogoTimer, SIGNAL( timeout() ), this, SLOT( handleRNLogoTimeout() ) ); + + mRNLogoTimer->start(); + } +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::handleRNLogoTimeout() +// ------------------------------------------------------------------------------------------------- +// +void VideoPlaybackControlsController::handleRNLogoTimeout() +{ + MPX_DEBUG(_L("VideoPlaybackControlsController::handleRNLogoTimeout()")); + + if ( mRNLogoTimer->isActive() ) + { + mRNLogoTimer->stop(); + } + + // + // Remove RN logo from the controls list and issue play command if needed + // + mControlsConfig->updateControlList( EControlCmdRemoveRNLogo ); + handleCommand( EMPXPbvCmdRealOneBitmapTimeout ); +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::isRNLogoBitmapInControlList() +// ------------------------------------------------------------------------------------------------- +// +bool VideoPlaybackControlsController::isRNLogoBitmapInControlList() +{ + bool exist = false; + + // + // If we have a rn logo in the list, we are supposed to show the logo all the time + // unless we are in the middle of orientation transition + // + for ( int i = 0 ; i < mControls.count() ; i++ ) + { + if ( mControls[i]->controlIndex() == ERealLogoBitmap ) + { + exist = true; + break; + } + } + + MPX_DEBUG(_L("VideoPlaybackControlsController::isRNLogoBitmapInControlList() [%d]"), exist); + + return exist; +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::handleOrientationChanged() +// ------------------------------------------------------------------------------------------------- +// +void VideoPlaybackControlsController::handleOrientationChanged( Qt::Orientation orientation ) +{ + MPX_ENTER_EXIT(_L("VideoPlaybackControlsController::handleOrientationChanged()"), + _L("old orientation %d, new orientation = %d"), mOrientation, orientation ); + + Qt::Orientation oldOrientaiton = mOrientation; + mOrientation = orientation; + + if ( oldOrientaiton == Qt::Vertical && orientation == Qt::Horizontal ) + { + showControls(); + } +} + +// ------------------------------------------------------------------------------------------------- +// VideoPlaybackControlsController::shouldShowRNLogo() +// ------------------------------------------------------------------------------------------------- +// +bool VideoPlaybackControlsController::shouldShowRNLogo() +{ + MPX_ENTER_EXIT(_L("VideoPlaybackControlsController::shouldShowRNLogo()")); + + bool showRNLogo = false; + + if ( mFileDetails->mRNFormat && + !mViewWrapper->IsResumingPlaybackAfterTermination() ) + { + showRNLogo = true; + } + + return showRNLogo; +} + +// End of File