/*
* Copyright (c) 2006 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:  Plays remote images on a renderer
*
*/


// INCLUDE FILES
// System
#include <aknnotewrappers.h>

// upnp stack api
#include <upnpobject.h>
#include <upnpitem.h>

// upnpframework / avcontroller api
#include "upnpavcontroller.h"
#include "upnpavrenderingsession.h"
#include "upnpavdevice.h"

// upnpframework / avcontroller helper api
#include "upnpitemutility.h"            // ResourceFromItemL

// upnpframework / internal api's
#include "upnpcdsreselementutility.h"

// commonui internal
#include "upnpimageplayer.h"
#include "upnpdeviceobserver.h"
#include <upnpcommonui.rsg>

_LIT( KComponentLogfile, "commonui.txt");
#include "upnplog.h"

// ============================ MEMBER FUNCTIONS ============================

// --------------------------------------------------------------------------
// CUpnpAVDevice::CUpnpAVDevice
// C++ default constructor can NOT contain any code, that
// might leave.
// --------------------------------------------------------------------------
//
CUpnpImagePlayer::CUpnpImagePlayer( MUPnPAVController& aAVControl,
                                    MUPnPDeviceObserver& aDialog,
                                    CUPnPCommonUI& aCommonUI ):
                                    iAVControl(aAVControl),
                                    iDialog(aDialog),
                                    iCommonUI(aCommonUI)
    {    
    __LOG( "CUpnpImagePlayer::CUpnpImagePlayer" );
    iImageState = EImageIdle;
    iFirstStart = ETrue;
    iAction = CUPnPCommonUI::EUPnPNone;
    __LOG( "CUpnpImagePlayer::CUpnpImagePlayer end" );
    }

// --------------------------------------------------------------------------
// CUpnpAVDevice::ConstructL
// Symbian 2nd phase constructor can leave.
// --------------------------------------------------------------------------
//
void CUpnpImagePlayer::ConstructL()
    {                        
    
    }

// --------------------------------------------------------------------------
// CUpnpAVDevice::NewL
// Two-phased constructor.
// --------------------------------------------------------------------------
//
CUpnpImagePlayer* CUpnpImagePlayer::NewL( 
                                    MUPnPAVController& aAVControl,
                                    MUPnPDeviceObserver& aDialog,
                                    CUPnPCommonUI& aCommonUI )
    {
    __LOG( "CUpnpImagePlayer::NewL" );
    CUpnpImagePlayer* self = new( ELeave )CUpnpImagePlayer( aAVControl,
                                                          aDialog,
                                                          aCommonUI );
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop( self );
    __LOG( "CUpnpImagePlayer::NewL end" );
    return self;
    }

// Destructor
CUpnpImagePlayer::~CUpnpImagePlayer()
    {   
    __LOG( "CUpnpImagePlayer::~CUpnpImagePlayer" );
    
    Stop();
    delete iUri;
    __LOG( "CUpnpImagePlayer::~CUpnpImagePlayer end" );
    }

// --------------------------------------------------------------------------
// CUpnpAVDevice::SetTargetDeviceL
// --------------------------------------------------------------------------
//
void CUpnpImagePlayer::SetTargetDeviceL( const CUpnpAVDevice& aTargetDevice )
    {
    __LOG( "CUpnpImagePlayer::SetTargetDeviceL" );
    iTargetDevice = &aTargetDevice;  
    iImageState = EImageIdle;
    
    if( iRendSession )
        {
        iRendSession->RemoveObserver();
        iAVControl.StopRenderingSession( *iRendSession );
        iRendSession = NULL;
        }
    iRendSession = &iAVControl.StartRenderingSessionL( *iTargetDevice );
    iRendSession->SetObserver( *this );
    
    __LOG( "CUpnpImagePlayer::SetTargetDeviceL end" );
    }
    
// --------------------------------------------------------------------------
// CUpnpAVDevice::PlayL
// --------------------------------------------------------------------------
//  
void CUpnpImagePlayer::PlayL( const CUpnpObject& aItem )
    {
    __LOG( "CUpnpImagePlayer::PlayL" );
    
    iAction = CUPnPCommonUI::EUPnPShow;
    iItem = static_cast<const CUpnpItem*>( &aItem );
    delete iUri; iUri = NULL;

    iUri = UPnPItemUtility::ResourceFromItemL( *iItem ).Value().AllocL();
    
    if( iImageState == EImageIdle )
        {
        if( iFirstStart )
            {
            iRendSession->SetURIL( *iUri, *iItem ); //not possible to leave 
            iImageState = EImageInitialising;
            delete iUri; iUri = NULL;    
            }
        else //stopping previously played item
            {
            iRendSession->StopL();
            iImageState = EImageNext;
            }
        }
    else
        {
        iImageState = EImageNext;                
        }

    __LOG( "CUpnpImagePlayer::PlayL end" );
    }

// --------------------------------------------------------------------------
// CUpnpAVDevice::Stop
// --------------------------------------------------------------------------
//  
void CUpnpImagePlayer::Stop()
    {
    if( iRendSession )
        {
        iImageState = EImageIdle;
        iFirstStart = ETrue;
        TRAP_IGNORE( iRendSession->StopL() );
        iRendSession->RemoveObserver();
        iAVControl.StopRenderingSession( *iRendSession );
        iRendSession = NULL;      
        }
    }

// --------------------------------------------------------------------------
// CUpnpAVDevice::InteractOperationComplete
// --------------------------------------------------------------------------
//
void CUpnpImagePlayer::InteractOperationComplete( 
              TInt aError,
              TUPnPAVInteractOperation aOperation 
              )
    {
    __LOG2( "CUpnpImagePlayer::InteractOperationComplete: %d, %d",
        aError, aOperation );
    TRAP_IGNORE( InteractOperationCompleteL( aError, aOperation ) );
    }

// --------------------------------------------------------------------------
// CUpnpAVDevice::InteractOperationCompleteL
// --------------------------------------------------------------------------
//
void CUpnpImagePlayer::InteractOperationCompleteL( 
              TInt aError,
              TUPnPAVInteractOperation aOperation 
              )
    {
    iCommonUI.HandleCommonErrorL( aError, NULL );
    
    switch( aOperation )
        {
        case EUPnPAVPlay:
            {
            if( iFirstStart )
                {
                iFirstStart = EFalse;    
                }
            
            if( iImageState == EImageNext ) //if still there is a pending item
                {                           //stop current showing item
                iRendSession->StopL();
                }
            else
                {
                iImageState = EImageIdle;
                }
            }
            break;
        case EUPnPAVStop:
            {
            if( iUri && iImageState == EImageNext )
                {
                iAction = CUPnPCommonUI::EUPnPShow;
                iRendSession->SetURIL( *iUri, *iItem );
                iImageState = EImageInitialising;
                delete iUri; iUri = NULL;    
                }
            }
            break;
        }
    }

// --------------------------------------------------------------------------
// CUpnpAVDevice::SetURIResult
// --------------------------------------------------------------------------
//
void CUpnpImagePlayer::SetURIResult( TInt aError )
    {
    __LOG1( "CUpnpImagePlayer::SetURIResult: %d", aError );
    
    TRAP_IGNORE( SetURIResultL( aError ) );
    }

// --------------------------------------------------------------------------
// CUpnpAVDevice::SetURIResultL
// --------------------------------------------------------------------------
//   
void CUpnpImagePlayer::SetURIResultL( TInt aError )
    {
    iCommonUI.GetUpnpAction( iAction );
    iCommonUI.HandleCommonErrorL( aError, NULL );
    if( iImageState == EImageNext ) //if there is another pending item
        {
        if( iUri )
            {
            iRendSession->SetURIL( *iUri, *iItem ); //not possible to leave
            iImageState = EImageInitialising;
            delete iUri; iUri = NULL;    
            }
        else
            {
            iImageState = EImageIdle;
            iCommonUI.GetUpnpAction( iAction );
            iCommonUI.HandleCommonErrorL( KErrNotFound, NULL );            
            }
        }
    else //if no pending item
        {
        if( KErrNone == aError )
            {
            iRendSession->PlayL(); //not possible to leave
            iImageState = EImageShowing;
            }
        else
            {
            iImageState = EImageIdle;
            }
        }
    }

// --------------------------------------------------------------------------
// CUpnpAVDevice::PlayL
// --------------------------------------------------------------------------
//
void CUpnpImagePlayer::MediaRendererDisappeared( 
                                 TUPnPDeviceDisconnectedReason aReason )
    {
    if( aReason == EDisconnected )
        {
        iDialog.DeviceDisappeared( KErrSessionClosed );
        }
    
    }
    
// End of File