/*

* Copyright (c) 2005-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:  Source file for UPnP Video player

*

*/

// INCLUDE FILES

// System

#include <aknlists.h>

#include <AknIconArray.h>

#include <aknnavilabel.h>

#include <aknnavide.h>

#include <akntitle.h>

#include <StringLoader.h>

#include <aknnotewrappers.h> 

#include <layoutmetadata.cdl.h> 

#include <AknWaitDialog.h>                      // CAknWaitDialog

#include <aknnotewrappers.h>

#include <AknVolumePopup.h>

#include<remconinterfaceselector.h>             //for CRemConInterfaceSelector

#include<remconcoreapitarget.h>                 //for CRemConCoreApiTarget

// upnp stack api

#include <upnpitem.h>

#include <upnpstring.h>

#include <upnpdevice.h>

// upnpframework / avcontroller api

#include "upnpavrenderingsession.h"

#include "upnpavdevice.h"

// upnpframework / avcontroller helper api

#include "upnpitemutility.h"                    // ResourceFromItemL

// upnpframework / internal api's

#include "upnpcommonutils.h"

#include "upnpcdsreselementutility.h"

// commonui internal

#include <upnpcommonui.rsg>

#include <upnpcommonui.mbg>

#include "upnpcommonui.h"

#include "upnpcommonui.hrh"

#include "upnpvideoplayerdialog.h"

#include "upnpperiodic.h"

_LIT( KComponentLogfile, "commonui.txt" );

#include "upnplog.h"

// CONSTANTS

const TInt KMPOneSecond(1000000);

const TInt KOneHourInSeconds(3600);

const TInt KMaxVolume(100);

const TInt KMiniumVolume(0);

const TInt KGetPosInfoPlaybackInterval( 10 );

const TInt KGetPosInfoBeforePlaybackInterval( 1 );

const TInt KLength = 100;

const TInt KDotLength = 3;

const TInt KVolumeStep = 1;

const TInt KVolumeInterval = 10;

_LIT( KAknMultiViewsMbmFileName,    "\\resource\\apps\\upnpcommonui.mbm" );

_LIT( KDot,                         "..." );

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

// --------------------------------------------------------------------------

// CUPnPVideoPlayerDlg::NewL

// Alternate two-phased constructor.

// --------------------------------------------------------------------------

//

CUPnPVideoPlayerDlg* CUPnPVideoPlayerDlg::NewL(

                                MUPnPAVRenderingSession& aRenderingSession,

                                const CUpnpObject& aObject,

                                CUPnPCommonUI& aCommonUI )

    {

    __LOG( "CUPnPVideoPlayerDlg::NewL" );

    CUPnPVideoPlayerDlg* self = NULL;

    self = new ( ELeave ) CUPnPVideoPlayerDlg( aRenderingSession,

                                             aObject,

                                             aCommonUI );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    __LOG( "CUPnPVideoPlayerDlg::NewL End" );

    return self;

    }

// --------------------------------------------------------------------------

// CUPnPVideoPlayerDlg::ConstructL

// Symbian 2nd phase constructor can leave.

// --------------------------------------------------------------------------

//

void CUPnPVideoPlayerDlg::ConstructL( )

    {

    __LOG( "CUPnPVideoPlayerDlg::ConstructL" );

    iAdjustingVolume = EFalse;

    // Resolve the target device capabilities

    ResolveTargetDeviceCapabilitiesL();

    iMinSecFormatString =

        iEikonEnv->AllocReadResourceL( R_QTN_TIME_DURAT_MIN_SEC );

    iHourMinSecFormatString = 

        iEikonEnv->AllocReadResourceL( R_QTN_TIME_DURAT_LONG );

    iNaviPane = static_cast<CAknNavigationControlContainer*>(

                CEikStatusPaneBase::Current()->

                ControlL( TUid::Uid( EEikStatusPaneUidNavi ) ) );

    iNaviPane->Pop();            

    iOriginalTitleText = HBufC16::NewL( KMaxFileName );

    iTimer = CUPnPPeriodic::NewL( CActive::EPriorityStandard );

    iCurrentVolume = KMiniumVolume; //0

    //create a vertical volume controller

    iVolumePopup = CAknVolumePopup::NewL( NULL, ETrue );

    //iVolumePopup->SetObserver( this );

    //set value to the volume popup    

    iVolumePopup->SetRange( KMiniumVolume , KMaxVolume );

    iVolumePopup->SetStepSize( KVolumeStep );     

    iVolumePopup->SetDefaultValue( KMiniumVolume );

     // Remote control server command repeat timer.

    iVolumeTimer = CUPnPPeriodic::NewL( EPriorityNormal );

    // Open a connection to receive Volume Key events.

    iInterfaceSelector = CRemConInterfaceSelector::NewL();

    // owned by CRemConInterfaceSelector instance

    iCoreTarget = CRemConCoreApiTarget::NewL( *iInterfaceSelector,*this );

    TRAPD( err, iInterfaceSelector->OpenTargetL() );

    if( err != KErrNone )

        {

        __LOG1("Leave occured in OpenTargetL %d", err);

        }

    __LOG( "CUPnPVideoPlayerDlg::ConstructL End" );                  

    }

// --------------------------------------------------------------------------

// CUPnPVideoPlayerDlg::CUPnPVideoPlayerDlg

// C++ default constructor can NOT contain any code, that

// might leave.

// --------------------------------------------------------------------------

//

CUPnPVideoPlayerDlg::CUPnPVideoPlayerDlg(

                                MUPnPAVRenderingSession& aRenderingSession,

                                const CUpnpObject& aObject,

                                CUPnPCommonUI& aCommonUI ):

                                iRendSession(aRenderingSession),

                                iCommonUI(aCommonUI)

    {

    __LOG( "CUPnPVideoPlayerDlg::CUPnPVideoPlayerDlg" );

    iTargetDevice = &( iRendSession.Device() );

    iItem = &aObject;

    iAction = CUPnPCommonUI::EUPnPNone;

    __LOG( "CUPnPVideoPlayerDlg::CUPnPVideoPlayerDlg End" );

    }

// --------------------------------------------------------------------------

// Destructor

// --------------------------------------------------------------------------

//

CUPnPVideoPlayerDlg::~CUPnPVideoPlayerDlg()

    {

    __LOG( "CUPnPVideoPlayerDlg::~CUPnPVideoPlayerDlg" );

    if( iVolumeTimer )

        {

        iVolumeTimer->Cancel();

        delete iVolumeTimer;

        }

    if( iVolumePopup )

        {

        iVolumePopup->CloseVolumePopup();

        }

    delete iVolumePopup;        

    delete iInterfaceSelector;

    if( iVideoPlaybackWaitNote )

        {

        TRAP_IGNORE( iVideoPlaybackWaitNote->ProcessFinishedL() );

        delete iVideoPlaybackWaitNote;

        iVideoPlaybackWaitNote = NULL;

        }

    if( iTimer )

        {

        iTimer->Cancel();

        }

    delete iTimer;

    delete iMinSecFormatString;

    delete iHourMinSecFormatString;

    delete iTimerNavi;

    delete iNaviDecorator;

    delete iOriginalTitleText;

    TRAP_IGNORE( iRendSession.StopL() );

    iRendSession.RemoveObserver();

    __LOG( "CUPnPVideoPlayerDlg::~CUPnPVideoPlayerDlg End" );    

    }

// --------------------------------------------------------------------------

// CUPnPVideoPlayerDlg::PreLayoutDynInitL();

// called by framework before dialog is shown

// --------------------------------------------------------------------------

//

void CUPnPVideoPlayerDlg::PreLayoutDynInitL()

    {

    __LOG( "CUPnPVideoPlayerDlg::PreLayoutDynInitL" );

    // Browse dialog title text

    TUid titlePaneUid;

    titlePaneUid.iUid = EEikStatusPaneUidTitle;

    CEikStatusPane* statusPane = iEikonEnv->AppUiFactory()->StatusPane();

    CEikStatusPaneBase::TPaneCapabilities titlesubPane =

                        statusPane->PaneCapabilities( titlePaneUid );

    if( titlesubPane.IsPresent() &&

        titlesubPane.IsAppOwned() )

        {

        CAknTitlePane* titlePane =

                (CAknTitlePane*) statusPane->ControlL( titlePaneUid );

        // Take backup of title text

        iOriginalTitleText->Des().Copy( *titlePane->Text() );

        HBufC *tmpbuf = UpnpString::ToUnicodeL( iItem->Title() );

        CleanupStack::PushL( tmpbuf );

        titlePane->SetTextL( *tmpbuf );

        CleanupStack::PopAndDestroy();

        }

    // Start to observe the rendering session

    iRendSession.RemoveObserver();

    iRendSession.SetObserver( *this );

    PreparePlayBackL();

    StartWaitNoteL();

/*

// Temporally commented out. Will be uncommented when UpnpAvController 

// provides cancel functionaly fot SetUri action (Upnp Fw 2.5)

    if( iExitCode == EEikBidCancel )

        {

        // Cancel the SetUri

        //iRendSession.Cancel();

        // Send Stop

        TRAP_IGNORE( iRendSession.StopL() );

        ClearTitleL();

        iExitCode = KErrCancel;

        }

*/

    User::LeaveIfError( iExitCode );

    if ( !Layout_Meta_Data::IsLandscapeOrientation() )

        {

        iEikonEnv->AppUiFactory()->StatusPane()->SwitchLayoutL(

                                 R_AVKON_STATUS_PANE_LAYOUT_USUAL );

        }

    // Volume level to 0

    iCurrentVolume = KMiniumVolume;

    // try to get volume level from renderer

    TRAPD( err, iRendSession.GetVolumeL() );

    if( !err )

        {

        iAdjustingVolume = ETrue;

        }

    __LOG( "CUPnPVideoPlayerDlg::PreLayoutDynInitL End" );

    }

// --------------------------------------------------------------------------

// CUPnPVideoPlayerDlg::OkToExitL(TInt aButtonId)

// called by framework when the softkey is pressed

// may leave without trap(System error)

// --------------------------------------------------------------------------

//

TBool CUPnPVideoPlayerDlg::OkToExitL( TInt aButtonId )

    {

    __LOG( "CUPnPVideoPlayerDlg::OkToExitL" );

    TBool retval = EFalse;

    TInt error = KErrNone;

    switch ( aButtonId )

        {

        case KErrSessionClosed: //either MS or MR disappears

        case KErrDisconnected: //fall through

            {

            // Connection failed so we have to close player

            TRAP_IGNORE( ClearTitleL() );

            return ETrue;

            }

        case EUPnPPauseCmd:

            {

            iAction = CUPnPCommonUI::EUPnPShow;

            TRAP( error, iRendSession.PauseL() );

            if ( KErrNone != error )

                {

                __LOG1( "CUPnPVideoPlayerDialog::OkToExitL:Pause %d",

                         error );

                }

            break;

            }

        case EUPnPReplayCmd:

            {

            iAction = CUPnPCommonUI::EUPnPShow;

            PreparePlayBackL();

            iExitCode = KErrNone;

            StartWaitNoteL();

/*

// Temporally commented out. Will be uncommented when UpnpAvController 

// provides cancel functionaly fot SetUri action (Upnp Fw 2.5)

            if( iExitCode == EEikBidCancel ||

                iExitCode == KErrCancel )

                {

                // Cancel the SetUri

                //iRendSession.Cancel();

                // Send Stop

                TRAP_IGNORE( iRendSession.StopL() );

                }

*/

            if( iExitCode == KErrSessionClosed ||

                iExitCode == KErrDisconnected )

                {

                TryExitL( iExitCode );

                }

            break;

            }

        case EUPnPContinueCmd:

            {

            iAction = CUPnPCommonUI::EUPnPShow;

            TRAP( error, iRendSession.PlayL() );

            if ( KErrNone != error )

                {

                __LOG1( "CUPnPVideoPlayerDialog::\

                                            OkToExitL: Continue %d", error );

                }

            break;

            }

        case EUPnPBackCmd: //quit the video player dialog

            {

            TRAP_IGNORE( ClearTitleL() ); //avoid system error

            return ETrue;            

            }

        case EUPnPStopCmd:

            {

            iAction = CUPnPCommonUI::EUPnPShow;

            TRAP( error, iRendSession.StopL() );

            if ( KErrNone != error )

                {

                __LOG1( "CUPnPVideoPlayerDialog::\

                                    OkToExitL: Stop %d", error );

                }

            break;

            }

        case EAknSoftkeyOk:

            {

            break;

            }

        case EAknSoftkeyCancel: 

        case EAknSoftkeyExit: 

        case EAknCmdExit: // fall through

        case EEikCmdExit:

            {

            TRAP_IGNORE( ClearTitleL() );

            return ETrue; //back to previous dialog

            }

        default:

            {

            // ignore

            break;

            }

        }

    __LOG( "CUPnPVideoPlayerDlg::OkToExitL End" );    

    return retval;

    }

// --------------------------------------------------------------------------

// CUPnPVideoPlayerDlg::UpdateSoftkeysL

// --------------------------------------------------------------------------

void CUPnPVideoPlayerDlg::UpdateSoftkeysL( TInt aState )

    {

    __LOG( "CUPnPVideoPlayerDlg::UpdateSoftkeysL" );

    if ( aState == EUPnPVideoPlay &&

         iPauseCapability )

        {

        ButtonGroupContainer().SetCommandSetL( 

                                    R_UPNPCOMMONUI_SOFTKEYS_PAUSE_STOP );

        ButtonGroupContainer().DrawDeferred();

        }

    else if ( aState == EUPnPVideoPlay &&

              !iPauseCapability )

        {

        ButtonGroupContainer().SetCommandSetL( 

                                    R_UPNPCOMMONUI_SOFTKEYS_EMPTY_STOP );

        ButtonGroupContainer().DrawDeferred();

        }

    else if ( aState == EUPnPVideoPause )

        {

        ButtonGroupContainer().SetCommandSetL(

                                    R_UPNPCOMMONUI_SOFTKEYS_CONTINUE_STOP );

        ButtonGroupContainer().DrawDeferred();

        }

    else if ( aState == EUPnPVideoStop )

        {

        ButtonGroupContainer().SetCommandSetL( 

                                    R_UPNPCOMMONUI_SOFTKEYS_REPLAY_BACK );

        ButtonGroupContainer().DrawDeferred();

        }

    __LOG( "CUPnPVideoPlayerDlg::UpdateSoftkeysL End" );    

    }

// --------------------------------------------------------------------------

// CUPnPVideoPlayerDlg::OfferKeyEventL

// --------------------------------------------------------------------------

//

TKeyResponse CUPnPVideoPlayerDlg::OfferKeyEventL( const TKeyEvent& aKeyEvent,

                                                  TEventCode aType )

    {

    __LOG( "CUPnPVideoPlayerDlg::OfferKeyEventL" );

    TKeyResponse response = EKeyWasConsumed;

    TInt error = KErrNone;

    if ( aType == EEventKeyUp )

        {

        if ( aKeyEvent.iScanCode == EStdKeyLeftArrow )

            {

            // Adjust volume if the target rendering device supports the

            // feature, and we are not waiting for a response for a previous

            // set volume action.

            iVolumeUp = EFalse;

            ChangeVolume( this );

            }

        else if ( aKeyEvent.iScanCode == EStdKeyRightArrow )

            {

            // Adjust volume if the target rendering device supports the

            // feature, and we are not waiting for a response for a previous

            // set volume action.

            iVolumeUp = ETrue;    

            ChangeVolume( this );

            }

        if( KErrNotReady == error ||

            KErrDisconnected == error )

            {

            TryExitL( error );

            }

        }

    else if( aType == EEventKey && aKeyEvent.iCode == EKeyEscape )

        {

        CAknDialog::OfferKeyEventL( aKeyEvent, aType );

        }

    __LOG( "CUPnPVideoPlayerDlg::OfferKeyEventL End" ); 

    return response;

    }

// --------------------------------------------------------------------------

// CUPnPVideoPlayerDlg::ShowVolumeIndicatorL

// --------------------------------------------------------------------------

//

void CUPnPVideoPlayerDlg::ShowVolumeIndicatorL()

    {

    __LOG( "CUPnPVideoPlayerDlg::ShowVolumeIndicatorL" );

    if ( iCurrentVolume >= KMiniumVolume && iCurrentVolume <= KMaxVolume )

        {

        __LOG( " - display volume popup indicator" );

        if ( iVolumePopup )

            {

            iVolumePopup->SetValue( iCurrentVolume );

            iVolumePopup->ShowVolumePopupL(); // will close after 1s

            }                

        }

    else

        {

        HideVolumeIdicator( this );

        }

    __LOG( "CUPnPVideoPlayerDlg::ShowVolumeIndicatorL End" );    

    }

// --------------------------------------------------------------------------

// CUPnPVideoPlayerDlg::HideVolumeIdicator

// --------------------------------------------------------------------------