/*
* Copyright (c) 2007-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: Source file for CUpnpShowTask class.
*
*/
// INCLUDE FILES
// upnp stack api
#include <upnpitem.h> // CUpnpItem
#include <upnpobject.h> // CUpnpObject (cast)
// upnpframework / avcontroller api
#include "upnpavcontroller.h" // MUPnPAVController
#include "upnpavrenderingsession.h" // MUPnPAVRenderingSession
#include "upnpavsessionobserverbase.h"
// upnpframework / avcontroller helper api
#include "upnpconstantdefs.h" // KFilterCommon, KClassVideo
#include "upnpitemresolver.h" // MUPnPItemResolver
#include "upnpitemresolverobserver.h" // MUPnPItemResolverObserver
#include "upnpitemresolverfactory.h" // UPnPItemResolverFactory
#include "upnpitemutility.h" // UPnPItemUtility::BelongsToClass
#include <upnpstring.h> // UpnpString::ToUnicodeL
// upnpframework / commonui
#include "upnpcommonui.h"
// command internal
#include "upnpfilepipe.h" // CUpnpFilePipe
#include "upnptaskhandler.h" // MUpnpTaskHandler
#include "upnptaskresourceallocator.h" // CUpnpTaskResourceAllocator
#include "upnpimagerenderingengine.h" // CUpnpImageRenderingEngine
#include "upnpshowtask.h"
#include "upnpcommand.h"
#include "upnpnotehandler.h" // CUpnpNoteHandler
#include "upnpavdevice.h"
_LIT( KComponentLogfile, "upnpcommand.log");
#include "upnplog.h"
// --------------------------------------------------------------------------
// CUpnpShowTask::NewL
// Creates an instance of the implementation.
// --------------------------------------------------------------------------
//
CUpnpTask* CUpnpShowTask::NewL()
{
__LOG( "[UpnpCommand]\t CUpnpShowTask::NewL" );
// Create instance
CUpnpShowTask* self = new (ELeave) CUpnpShowTask();
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop( self );
return self;
}
// --------------------------------------------------------------------------
// CUpnpShowTask::CUpnpShowTask
// First phase construction.
// --------------------------------------------------------------------------
//
CUpnpShowTask::CUpnpShowTask()
{
__LOG( "[UpnpCommand]\t CUpnpShowTask::Constructor" );
}
// --------------------------------------------------------------------------
// Destructor.
// --------------------------------------------------------------------------
//
CUpnpShowTask::~CUpnpShowTask()
{
__LOG( "[UpnpCommand]\t CUpnpShowTask::Destructor" );
Cleanup();
}
// --------------------------------------------------------------------------
// CUpnpShowTask::Cleanup
// --------------------------------------------------------------------------
//
void CUpnpShowTask::Cleanup()
{
__LOG( "[UpnpCommand]\t CUpnpShowTask::Cleanup" );
delete iRenderingEngine;
iRenderingEngine = NULL;
// delete the resource allocator
// Local mediaserver and AVController resources will be freed.
delete iResourceAllocator;
iResourceAllocator = NULL;
iRenderingSession = NULL;
iVideoRenderingSession = NULL;
delete iCommonUI;
iCommonUI = NULL;
__LOG( "[UpnpCommand]\t CUpnpShowTask::Cleanup - end" );
}
// --------------------------------------------------------------------------
// CUpnpShowTask::ConstructL
// Perform the second phase of two phase construction. Reserves the Upnp Fw
// resources (they are released when the task is destroyed).
// --------------------------------------------------------------------------
//
void CUpnpShowTask::ConstructL()
{
__LOG( "[UpnpCommand]\t CUpnpShowTask::ConstructL" );
// create common UI
iCommonUI = CUPnPCommonUI::NewL();
// create the resource allocator
iResourceAllocator = CUpnpTaskResourceAllocator::NewL(
*iCommonUI,
CUpnpTaskResourceAllocator::EResourceAvController |
/*CUpnpTaskResourceAllocator::EResourceLocalMediaServer |*/
CUpnpTaskResourceAllocator::EResourceSelectImageRenderer );
iShowPlaybackFailedNote = ETrue;
}
// --------------------------------------------------------------------------
// CUpnpShowTask::AllocateResourcesL
// Allocates the Upnp Fw resources.
// --------------------------------------------------------------------------
//
void CUpnpShowTask::AllocateResourcesL()
{
__LOG( "[UpnpCommand]\t CUpnpShowTask::AllocateResourcesL" );
iResourceAllocator->SetNoteHandlerL( NoteHandler() );
NoteHandler()->ResetDrmNoteCount();
// now allocate!
iResourceAllocator->AllocateL();
// start a rendering session
iRenderingSession =
&iResourceAllocator->AVController().StartRenderingSessionL(
iResourceAllocator->SelectedDevice() );
// create image rendering engine
iRenderingEngine = CUpnpImageRenderingEngine::NewL(
iResourceAllocator->AVController(),
*iRenderingSession,
*this );
}
// --------------------------------------------------------------------------
// CUpnpShowTask::ExecuteL
// Executes the task.
// --------------------------------------------------------------------------
//
void CUpnpShowTask::ExecuteL()
{
__LOG( "[UpnpCommand]\t CUpnpShowTask::ExecuteL" );
// assert that required resources exist
__ASSERT( iRenderingEngine, __FILE__, __LINE__ );
if( iPlayingVideo )
{
// if videoplayerdlg is active, we cannot start rendering new file
// before user closes the dialog
__LOG( "[UpnpCommand]\t CUpnpShowTask::ExecuteL\
video already playing, do nothing" );
}
else
{
// start rendering process on the engine
iRenderingEngine->PlayL();
}
}
// --------------------------------------------------------------------------
// CUpnpShowTask::GetMedia
// provide media to be played back
// --------------------------------------------------------------------------
MUPnPItemResolver* CUpnpShowTask::GetMedia()
{
__ASSERT( FilePipe(), __FILE__, __LINE__ );
__LOG1( "[UpnpCommand]\t CUpnpShowTask::GetMedia cnt %d",
FilePipe()->Count() );
MUPnPItemResolver* resolver = 0;
if ( FilePipe()->Count() > 0 )
{
const TDesC& filename = FilePipe()->FileAt( 0 );
__LOG1( "[UpnpCommand]\t CUpnpShowTask::GetMedia: %S", &filename );
TRAP_IGNORE (
resolver =
UPnPItemResolverFactory::NewLocalItemResolverL(
filename,
iResourceAllocator->AVController(),
iSelector,
UPnPItemResolverFactory::EOmitLocalMSStart );
);
}
return resolver;
}
// --------------------------------------------------------------------------
// CUpnpShowTask::RenderAck
// Callback from image rendering engine.
// --------------------------------------------------------------------------
TInt CUpnpShowTask::RenderAck(
TInt aError,
const CUpnpItem* aItem )
{
__LOG1( "[UpnpCommand]\t CUpnpShowTask::RenderAck aError %D", aError );
if ( aError == KErrNotSupported && aItem &&
UPnPItemUtility::BelongsToClass( *aItem, KClassVideo ) )
{
// NOTE!
// This is a special case. For video playback we use the image
// rendering engine for resolving, and then it fails with
// KErrNotSupported, because it is not an image. Now we catch the
// error here and play the resolved item. Why that complicated ?
// - to keep image rendering engine for image rendering ONLY
// and not to mix video UI stuff in there
// - to enable image rendering engine reuse in the future
// - so that we do not have to rewrite the resolving code in
// another place, it already exists in image rendering engine.
aError = PlayVideo( *aItem );
}
// disconnect and renderer busy messages are handled in EngineShutdown
// other errors are handled here
if ( aError != KErrDisconnected )
{
if ( aError == KErrNotSupported || aError == KErrPermissionDenied )
{
// protected file
TRAP_IGNORE( NoteHandler()->ShowDrmNoteL() );
}
else if( aError != KErrNone && iShowPlaybackFailedNote )
{
// unknown error -> show general note
// note is shown only once per session
TRAP_IGNORE( NoteHandler()->ShowPlaybackFailedNoteL() );
iShowPlaybackFailedNote = EFalse;
}
// inform observer
CommandEvent( UpnpCommand::EEventComplete, aError );
}
__LOG1( "[UpnpCommand]\t RenderAck end, resp=%d", aError );
return aError;
}
// --------------------------------------------------------------------------
// CUpnpShowTask::EngineShutdown
// Callback from image rendering engine.
// --------------------------------------------------------------------------
void CUpnpShowTask::EngineShutdown(
TInt aError )
{
if ( iPlayingVideo )
{
__LOG1( "[UpnpCommand]\t CUpnpShowTask::EngineShutdown(%d)\
while video playing",
aError );
TRAP_IGNORE( iCommonUI->DismissDialogL( aError ) );
}
else
{
__LOG1( "[UpnpCommand]\t CUpnpShowTask::EngineShutdown(%d)",
aError );
if( aError == KErrDisconnected )
{
__ASSERTD( iRenderingEngine, __FILE__, __LINE__ );
// check from rendering engine if wlan is active
// note shown only in device disappeared cases
if( iRenderingEngine->IsWlanActive() )
{
TRAP_IGNORE( NoteHandler()->ShowConnectionLostNoteL() );
}
}
else if( aError == KErrInUse )
{
// renderer is used by another controlpointš
if ( iRenderingSession )
{
TRAP_IGNORE( HBufC* rendererName = UpnpString::ToUnicodeL(
iRenderingSession->Device().FriendlyName() );
CleanupStack::PushL( rendererName );
iRenderingSession->Device().FriendlyName();
NoteHandler()->ShowRendererInUseNoteL(*rendererName);
CleanupStack::PopAndDestroy( rendererName );
);
}
}
// Inform the observer
__ASSERT( TaskHandler(), __FILE__, __LINE__ );
CommandEvent( UpnpCommand::EEventComplete, aError, ETrue );
}
__LOG( "[UpnpCommand]\t CUpnpShowTask::EngineShutdown END" );
}
// --------------------------------------------------------------------------
// CUpnpShowTask::PlayVideo
// Launches the video player dialog for playing a video file on remote
// --------------------------------------------------------------------------
TInt CUpnpShowTask::PlayVideo( const CUpnpItem& aItem )
{
__LOG( "[UpnpCommand]\t CUpnpShowTask::CUpnpShowTask::PlayVideo start" );
TInt videoPlayerError = KErrNone;
TInt videoStatus = KErrNone;
// Update the state
iPlayingVideo = ETrue;
// Launch the video player dialog to render the item.
TRAP( videoPlayerError,
// start a rendering session ( used only for video playing )
if( !iVideoRenderingSession )
{
iVideoRenderingSession =
&iResourceAllocator->AVController().StartRenderingSessionL(
iResourceAllocator->SelectedDevice() );
}
// inform observer that we are launching dialog
__LOG( "[UpnpCommand]\t CUpnpShowTask::CUpnpShowTask::PlayVideo \
launching videoplayerdialog" );
CommandEvent( UpnpCommand::EEventProgress,
UpnpCommand::KUpnpCommandStatusStartPlayVideo, EFalse );
// plays video
videoStatus = iCommonUI->ExecuteVideoPlayerL(
*iVideoRenderingSession, aItem );
)
// Update the state
iPlayingVideo = EFalse;
// Fix UpnpCommonUi's return value
if( videoStatus > 0 )
{
videoStatus = KErrNone;
}
if( videoPlayerError != KErrNone &&
videoStatus == KErrNone )
{
videoStatus = videoPlayerError;
}
__LOG( "[UpnpCommand]\t CUpnpShowTask::CUpnpShowTask::PlayVideo end" );
// Inform the observer, no matter if the playing succeeded or failed.
return videoStatus;
}
// End of File