/*

* Copyright (c) 2008 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 Video base playback view

*

*/

//  Include Files

#include <aknViewAppUi.h>

#include <w32std.h>

#include <eikenv.h>

#include <bautils.h>

#include <AknUtils.h>

#include <coemain.h>

#include <hlplch.h>

#include <akntoolbar.h>

#include <AknUtils.h>

#include <data_caging_path_literals.hrh>

#include <mpxplaybackcommanddefs.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxcommand.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxplaybackmessage.h>

#include <mpxmediageneraldefs.h>

#include <mpxplaybackutility.h>

#include <mpxviewutility.h>

#include <StringLoader.h>

#include <aknnotewrappers.h>

#include <mpxvideoplaybackviews.rsg>

#include <textresolver.h>

#include <mmf/common/mmferrors.h>

#include <DRMHelper.h>

#include <mpxcollectionutility.h>

#include <mpxcollectionutility.h>

#include <mpxcollectionplaylist.h>

#include <mpxcollectionpath.h>

#include <mpxmediageneralextdefs.h>

#include <vcxmyvideosuids.h>

#include <drmuihandling.h>

#include <drmerrorhandling.h>

#include "mpxvideobaseplaybackview.h"

#include "mpxvideoplaybackcontainer.h"

#include "mpxvideoplaybackcontrol.hrh"

#include "mpxcommonvideoplaybackview.hrh"

#include "mpxvideoplaybackviewfiledetails.h"

#include "mpxvideoplaybackuids.hrh"

#include "MPFileDetailsDialog.h"

#include <mpxvideoplaybackdefs.h>

#include "mpxmediavideodefs.h"

#include "mpxvideo_debug.h"

#include "mpxvideoplayercustomviewmsgconsts.h"

//

//  Set a constant for the information timeout of 5 seconds

//

const TInt KInformationNoteTimeout = 5000000;

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

// CMPXVideoBasePlaybackView::CMPXVideoBasePlaybackView()

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

//

CMPXVideoBasePlaybackView::CMPXVideoBasePlaybackView()

// note, CBase initialises all member variables to zero

{

}

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

//   CMPXVideoBasePlaybackView::InitializeVideoPlaybackViewL()

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

//

void CMPXVideoBasePlaybackView::InitializeVideoPlaybackViewL()

{

    MPX_ENTER_EXIT(_L("CMPXVideoBasePlaybackView::InitializeVideoPlaybackViewL()"));

    _LIT( KMPXVideoPlaybackViewsRscPath, "mpxvideoplaybackviews.rsc" );

    CCoeEnv* coeEnv = iEikonEnv;

    TParse parse;

    parse.Set( KMPXVideoPlaybackViewsRscPath, &KDC_APP_RESOURCE_DIR, NULL );

    TFileName resourceFile = parse.FullName();

    User::LeaveIfError( AddDllPath( resourceFile ) );

    BaflUtils::NearestLanguageFile( coeEnv->FsSession(), resourceFile );

    iVideoResourceOffset = coeEnv->AddResourceFileL( resourceFile );

    //

    //  Get an instance of view utility

    //

    iViewUtility = MMPXViewUtility::UtilityL();

    //

    //  Get an instance of collection utility

    //  Used for the Collection Observer to get the MediaL callbacks

    //

    iCollectionUtility = MMPXCollectionUtility::NewL( this );

    //

    //  Create Active Object for closing player

    //

    iCloseAO = CIdle::NewL( CActive::EPriorityStandard );

    BaseConstructL( R_MPX_VIDEO_PLAYBACK_VIEW );

    iAknEventMonitor = static_cast<CAknAppUiBase*>(CCoeEnv::Static()->AppUi())->EventMonitor();

}

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

// CMPXVideoBasePlaybackView::~CMPXVideoBasePlaybackView()

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

//

CMPXVideoBasePlaybackView::~CMPXVideoBasePlaybackView()

{

    MPX_DEBUG(_L("CMPXVideoBasePlaybackView::~CMPXVideoBasePlaybackView()"));

    if ( iClipName )

    {

        delete iClipName;

        iClipName = NULL;

    }

    if ( iCloseAO )

    {

        delete iCloseAO;

        iCloseAO = NULL;

    }

    if ( iFileDetails )

    {

        delete iFileDetails;

        iFileDetails = NULL;

    }

    if ( iDisplayHandler )

    {

        delete iDisplayHandler;

        iDisplayHandler = NULL;

    }

    if ( iPlaybackUtility )

    {

        TRAP_IGNORE( iPlaybackUtility->RemoveObserverL( *this ) );

        iPlaybackUtility->Close();

        iPlaybackUtility = NULL;

    }

    if ( iViewUtility )

    {

        iViewUtility->Close();

        iViewUtility = NULL;

    }

    if ( iCollectionUtility )

    {

        iCollectionUtility->Close();

    }

    if ( iVideoResourceOffset )

    {

        iEikonEnv->DeleteResourceFile( iVideoResourceOffset );

    }

    if ( iContainer )

    {

        AppUi()->RemoveFromStack( iContainer );

        delete iContainer;

        iContainer = NULL;

    }

}

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

//   CMPXVideoBasePlaybackView::CreateGeneralPlaybackCommandL()

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

//

{

    MPX_ENTER_EXIT(_L("CMPXVideoBasePlaybackView::CreateGeneralPlaybackCommandL()"),

                   _L("aCmd = %d, aDoSync, = %d"), aCmd, aDoSync );

    CMPXCommand* cmd = CMPXCommand::NewL();

    CleanupStack::PushL( cmd );

    cmd->SetTObjectValueL<TBool>( KMPXCommandGeneralDoSync, aDoSync );

    cmd->SetTObjectValueL<TBool>( KMPXCommandPlaybackGeneralNoBuffer, ETrue );

    cmd->SetTObjectValueL<TInt>( KMPXCommandGeneralId, KMPXCommandIdPlaybackGeneral );

    cmd->SetTObjectValueL<TInt>( KMPXCommandPlaybackGeneralType, aCmd );

    iPlaybackUtility->CommandL( *cmd, this );

    CleanupStack::PopAndDestroy( cmd );

}

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

//   CMPXVideoBasePlaybackView::HandleCommandL()

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

//

void CMPXVideoBasePlaybackView::HandleCommandL( TInt aCommand )

{

    MPX_ENTER_EXIT(

        _L("CMPXVideoBasePlaybackView::HandleCommandL()"),

        _L("aCommand = %d"), aCommand );

    switch ( aCommand )

    {

        case EMPXPbvCmdPlay:

        {

            IssuePlayCommandL();

            break;

        }

        case EMPXPbvCmdPause:

        {

            MPX_DEBUG(_L("CMPXVideoBasePlaybackView::HandleCommandL() EMPXPbvCmdPause"));

            CreateGeneralPlaybackCommandL( EPbCmdPause );

            break;

        }

        case EAknSoftkeyClose:

        case EMPXPbvCmdClose:

        {

            MPX_DEBUG(_L("CMPXVideoBasePlaybackView::HandleCommandL() EMPXPbvCmdClose"));

            break;

        }

        case EMPXPbvCmdSeekForward:

        {

            MPX_DEBUG(_L("CMPXVideoBasePlaybackView::HandleCommandL() EMPXPbvCmdSeekForward"));

            CreateVideoSpecificCmdL( EPbCmdStartVideoSeekingForward );

            break;

        }

        case EMPXPbvCmdSeekBackward:

        {

            MPX_DEBUG(_L("CMPXVideoBasePlaybackView::HandleCommandL() EMPXPbvCmdSeekBackward"));

            CreateVideoSpecificCmdL( EPbCmdStartVideoSeekingBackward );

            break;

        }

        case EMPXPbvCmdEndSeek:

        {

            MPX_DEBUG(_L("CMPXVideoBasePlaybackView::HandleCommandL() EMPXPbvCmdEndSeek"));

            CreateVideoSpecificCmdL( EPbCmdStopVideoSeeking );

            break;

        }

        case EMPXPbvCmdPlayPause:

        {

            MPX_DEBUG(_L("CMPXVideoBasePlaybackView::HandleCommandL() EMPXPbvCmdPause"));

            iPlaybackUtility->CommandL( EPbCmdPlayPause );

            break;

        }

        case EAknSoftkeyBack:

        {

            ClosePlaybackViewL();

            break;

        }

        case EMPXPbvCmdStop:

        {

            MPX_DEBUG(_L("CMPXVideoBasePlaybackView::HandleCommandL() EMPXPbvCmdStop"));

            CreateGeneralPlaybackCommandL( EPbCmdStop );

            break;

        }

        case EMPXPbvCmdDecreaseVolume:

        {

            MPX_DEBUG(_L("CMPXVideoBasePlaybackView::HandleCommandL() EMPXPbvCmdDecreaseVolume"));

            HandleVolumeCmdL( EPbCmdDecreaseVolume );

            break;

        }

        case EMPXPbvCmdIncreaseVolume:

        {

            MPX_DEBUG(_L("CMPXVideoBasePlaybackView::HandleCommandL() EMPXPbvCmdIncreaseVolume"));

            HandleVolumeCmdL( EPbCmdIncreaseVolume );

            break;

        }

        case EMPXPbvCmdNaturalAspectRatio:

        {

            MPX_DEBUG(

                _L("CMPXVideoBasePlaybackView::HandleCommandL() EMPXPbvCmdNaturalAspectRatio"));

            SetAspectRatioL( EPbCmdNaturalAspectRatio );

            break;

        }

        case EMPXPbvCmdZoomAspectRatio:

        {

            MPX_DEBUG(

                _L("CMPXVideoBasePlaybackView::HandleCommandL() EMPXPbvCmdZoomAspectRatio"));

            SetAspectRatioL( EPbCmdZoomAspectRatio );

            break;

        }

        case EMPXPbvCmdStretchAspectRatio:

        {

            MPX_DEBUG(

                _L("CMPXVideoBasePlaybackView::HandleCommandL() EMPXPbvCmdStretchAspectRatio"));

            SetAspectRatioL( EPbCmdStretchAspectRatio );

            break;

        }

        case EMPXPbvCmdMute:

        {

            MPX_DEBUG(_L("CMPXVideoBasePlaybackView::HandleCommandL() EMPXPbvCmdMute"));

            HandleVolumeCmdL( EPbCmdMuteVolume );

            break;

        }

        case EMPXPbvCmdUnMute:

        {

            MPX_DEBUG(_L("CMPXVideoBasePlaybackView::HandleCommandL() EMPXPbvCmdUnMute"));

            HandleVolumeCmdL( EPbCmdUnMuteVolume );

            break;

        }

        case EMPXPbvCmdShortPressBackward:

        {

            MPX_DEBUG(_L("CMPXVideoBasePlaybackView::HandleCommandL() EMPXPbvCmdShortPressBackward"));

            HandleShortPressBackwardL();

            break;

        }

        case EAknCmdHelp:

        {

            HlpLauncher::LaunchHelpApplicationL( iEikonEnv->WsSession(),

                                                 AppUi()->AppHelpContextL() );

            break;

        }

        case EMPXPbvCmdShowFileDetails:

        {

            if ( AknLayoutUtils::PenEnabled() )

            {

                iContainer->HandleEventL( EMPXControlCmdShowFileDetailsViewer );

            }

            else

            {

                ShowFileDetailsDialogL();

            }

            break;

        }

        case EMPXPbvCmdEndOfClip:

        {

            CreateVideoSpecificCmdL( EPbCmdEndofClipReached );

            break;

        }

        case EMPXPbvCmdCustomPause:

        {

            CreateVideoSpecificCmdL( EPbCmdCustomPause );

            break;

        }

        case EMPXPbvCmdCustomPlay:

        {

            CreateVideoSpecificCmdL( EPbCmdCustomPlay );

            break;

        }

        case EMPXPbvLaunchDRMDetails:

        {

            LaunchDRMDetailsL();

            break;

        }

        case KMpxVideoPlaybackPdlReloading:

        {

            iPdlReloading = ETrue;

            iMediaRequested = EFalse;

            break;

        }

        case KMpxVideoPlaybackPdlReloadComplete:

        {

            HandlePdlReloadComplete();

            break;

        }

        case EMPXPbvCmdRealOneBitmapTimeout:

        {

            HandleRealOneBitmapTimeoutL();

            break;

        }

    }

}

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

//   CMPXVideoBasePlaybackView::ProcessCommandL()

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

//

void CMPXVideoBasePlaybackView::ProcessCommandL( TInt aCommand )

{

    MPX_ENTER_EXIT(

        _L("CMPXVideoBasePlaybackView::ProcessCommandL()"),

        _L("aCommand = %d"), aCommand );

    if ( aCommand == EAknCmdExit )

    {

        MPX_DEBUG(_L("CMPXVideoBasePlaybackView::ProcessCommandL() EAknCmdExit"));

        if ( MenuBar() )

        {

            MenuBar()->StopDisplayingMenuBar();

        }

    }

    CAknView::ProcessCommandL( aCommand );

}

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

//   CMPXVideoBasePlaybackView::HandleStatusPaneSizeChange()

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

//

void CMPXVideoBasePlaybackView::HandleStatusPaneSizeChange()

{

    MPX_DEBUG(_L("CMPXVideoBasePlaybackView::HandleStatusPaneSizeChange()"));

}

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

//   CMPXVideoBasePlaybackView::DoActivateL()

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

//

void CMPXVideoBasePlaybackView::DoActivateL( const TVwsViewId& /* aPrevViewId */,

                                             TUid /* aCustomMessageId */,

                                             const TDesC8& /* aCustomMessage */ )

{

    MPX_ENTER_EXIT(_L("CMPXVideoBasePlaybackView::DoActivateL()"));

    //

    //  Get the playback utility instance from playback utility

    //

    iPlaybackUtility = MMPXPlaybackUtility::UtilityL( EMPXCategoryVideo, KPbModeDefault );

    iPlaybackUtility->AddObserverL( *this );

    iPlaybackUtility->SetPrimaryClientL();

    //

    //  Initialize the playback state

    //

    iPlaybackState = iPlaybackUtility->StateL();

    //

    //  Observe the View Framework when the view is active

    //

    iViewUtility->AddObserverL( this );

    //

    //  Disable tool bar in playback view

    //

    AppUi()->CurrentFixedToolbar()->SetToolbarVisibility( EFalse );

    if ( ! iContainer )

    {

        AppUi()->SetOrientationL( CAknAppUiBase::EAppUiOrientationLandscape );

        iContainer = CMPXVideoPlaybackContainer::NewL( this );

        AppUi()->AddToStackL( *this, iContainer );

        iContainer->GetWindow().SetVisible( ETrue );

        //

        //  Create Video Playback Display Handler

        //

        iDisplayHandler = CMPXVideoPlaybackDisplayHandler::NewL( iPlaybackUtility, iContainer );

    }

    //

    //  Register for window visibility changes

    //

    iContainer->GetWindow().EnableVisibilityChangeEvents();

    iKeyboardInFocus = ETrue;

    iAknEventMonitor->Enable( ETrue );

    iAknEventMonitor->AddObserverL( this );

    //

    //  Determine if the playback is from a playlist on view activation

    //

    MMPXSource* s = iPlaybackUtility->Source();

    CMPXCollectionPlaylist* playlist = s->PlaylistL();

    iPlaylistView = (playlist) ? ETrue : EFalse;

    delete playlist;

    //

    //  Retrieve PDL information for container

    //

    RetrievePdlInformationL();

    //

    //  Request the needed Media from the Playback Plugin

    //

    RequestMediaL();

}

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

// From CAknView

// View deactivation function.

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

//

void CMPXVideoBasePlaybackView::DoDeactivate()

{

    MPX_ENTER_EXIT(_L("CMPXVideoBasePlaybackView::DoDeactivate()"));

    //

    //  Close the playback plugin to release all references to previous clip

    //

    MPX_TRAPD( err, HandleCommandL( EMPXPbvCmdClose ) );

    iAknEventMonitor->Enable( EFalse );

    iAknEventMonitor->RemoveObserver( this );

    iKeyboardInFocus = EFalse;

    //

    //  Delete the display handler when the view is deactivated

    //

    if ( iDisplayHandler )

    {

        delete iDisplayHandler;

        iDisplayHandler = NULL;

    }

    if ( iPlaybackUtility )