/*

* 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:  CMpxVideoPlayerAppUiEngine

 *

*/

#include <mpxcommand.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxplaybackmessage.h>

#include <mpxplaybackutility.h>

#include <mpxcollectionmessage.h>

#include <mpxmediageneraldefs.h>

#include <mpxcollectionmessagedefs.h>

#include <vcxmyvideosdefs.h>

#include <mpxcollectionpath.h>

#include <videoplayeractivationmessage.h>

#include <mpxcollectionuihelper.h>

#include <mpxcollectionhelperfactory.h>

#include <mpxcollectionplugin.hrh>

#include <mpxmediageneralextdefs.h>

#include <mmf/common/mmfcontrollerframeworkbase.h>

#include <coeutils.h>

#include <videoplaylistutility.h>

#include <mpxvideoplaybackdefs.h>

#include "mpxvideoplayerappuiengine.h"

#include "mpxvideoplayerconstants.h"

#include "mpxhbvideocommondefs.h"

#include "mpxvideo_debug.h"

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

//   CMpxVideoPlayerAppUiEngine::CMpxVideoPlayerAppUiEngine

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

//

    : iPlaybackUtility( NULL ),

      iCollectionUtility( NULL ),

      iRecognizer( NULL ),

      iAccessPointId( KUseDefaultIap ),

      iMultilinkPlaylist( EFalse ),

      iSeekable( ETrue ),

      iUpdateSeekInfo( EFalse ),

      iPlaybackWrapper( aWrapper )

{

}

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

//   CMpxVideoPlayerAppUiEngine::NewL

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

//

{

    MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::NewL()"));

    CMpxVideoPlayerAppUiEngine* self = new( ELeave) CMpxVideoPlayerAppUiEngine( aWrapper );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

}

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

//   CMpxVideoPlayerAppUiEngine::ConstructL

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

//

void CMpxVideoPlayerAppUiEngine::ConstructL()

{    

    TUid collectionMode( KUidMpxVideoPlayerApplication );

    iCollectionUtility = MMPXCollectionUtility::NewL( this, collectionMode ); 

}

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

//   CMpxVideoPlayerAppUiEngine::PostInitL

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

//

void CMpxVideoPlayerAppUiEngine::LateInitL()

{	       

    CreatePlaybackUtilityL();

    if ( ! iRecognizer )

    {

        iRecognizer = CMediaRecognizer::NewL();

    }

}

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

//   CMpxVideoPlayerAppUiEngine::CreateCollectionUtilityMemberVariablesL

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

//

void CMpxVideoPlayerAppUiEngine::CreateCollectionUtilityMemberVariablesL()

{

    MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::CreateCollectionUtilityMemberVariablesL()"));

    if ( ! iCollectionUtility )

    {

        //  PLAYLIST default mode

        iCollectionUtility = MMPXCollectionUtility::NewL( this );

    }

    if ( ! iCollectionUiHelper )

    {

        iCollectionUiHelper = CMPXCollectionHelperFactory::NewCollectionUiHelperL();

    }

}

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

//   CMpxVideoPlayerAppUiEngine::CreatePlaybackUtilityL

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

//

void CMpxVideoPlayerAppUiEngine::CreatePlaybackUtilityL()

{

    MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::CreatePlaybackUtilityL()"));

    if ( ! iPlaybackUtility )

    {

        //

        //  Create VideoHelix playback plugin

        //

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

        MMPXPlayerManager& manager = iPlaybackUtility->PlayerManager();

        manager.SelectPlayerL( KVideoHelixPlaybackPluginUid );

        iPlaybackUtility->AddObserverL( *this );

        iPlaybackUtility->CommandL( EPbCmdSetAutoResume, EFalse );

    }

}

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

//   CMpxVideoPlayerAppUiEngine::~CMpxVideoPlayerAppUiEngine

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

//

CMpxVideoPlayerAppUiEngine::~CMpxVideoPlayerAppUiEngine()

{

    MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::~CMpxVideoPlayerAppUiEngine()"));

    if ( iRecognizer )

    {

        delete iRecognizer;

        iRecognizer = NULL;

    }

    if ( iCollectionUtility )

    {

        iCollectionUtility->Close();

    }

    if ( iCollectionUiHelper )

    {

        iCollectionUiHelper->Close();

    }

    if ( iPlaybackUtility )

    {

        TRAP_IGNORE( iPlaybackUtility->CommandL( EPbCmdClose ) );

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

        iPlaybackUtility->Close();

    }

}

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

// From MMPXPlaybackObserver

// Handle playback message.

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

//

void CMpxVideoPlayerAppUiEngine::HandlePlaybackMessage( CMPXMessage* aMessage, TInt aError )

{

    MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::HandlePlaybackMessage()"));

    if ( aError == KErrNone && aMessage )

    {

        TRAP_IGNORE( DoHandlePlaybackMessageL( *aMessage ) );

    }

}

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

// From MMPXViewActivationObserver.

// Handle view activation.

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

//

void CMpxVideoPlayerAppUiEngine::HandleViewActivation( const TUid& /*aCurrentViewType*/,

                                                       const TUid& /*aPreviousViewType*/ )

{

}

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

//   CMpxVideoPlayerAppUiEngine::OpenFileL

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

//

void CMpxVideoPlayerAppUiEngine::OpenFileL( RFile& aFile )

{

    MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::OpenFileL(RFile)"));

    TFileName filename;

    aFile.FullName(filename);

    LateInitL();

    CMediaRecognizer::TMediaType mediaType = iRecognizer->IdentifyMediaTypeL( filename, aFile );

    if ( mediaType == CMediaRecognizer::ELocalRamFile ||

         mediaType == CMediaRecognizer::ELocalAsxFile )

    {

        HandleMultiLinksFileL( aFile, mediaType );

    }

    else if ( mediaType == CMediaRecognizer::ELocalSdpFile )

    {

        iPlaybackUtility->InitStreamingL( aFile, iAccessPointId );

    }

    else

    {

        iPlaybackUtility->InitL( aFile );

    }    

    iRecognizer->FreeFilehandle();

    aFile.Close();

}

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

//   CMpxVideoPlayerAppUiEngine::OpenFileL

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

//

void CMpxVideoPlayerAppUiEngine::OpenFileL( const TDesC& aFileName )

{

    MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::OpenFileL()"),

                   _L("aFileName = %S"), &aFileName);    

    LateInitL();

    CMediaRecognizer::TMediaType mediaType = iRecognizer->IdentifyMediaTypeL(aFileName);

    if ( mediaType == CMediaRecognizer::ELocalVideoFile )

    {

        iPlaybackUtility->InitL( aFileName );

    }

    // check if aFileName is a path to a ram or asx file

    //          eg. c:\\data\\videos\\ramfile.ram

    else if ( mediaType == CMediaRecognizer::ELocalRamFile ||

              mediaType == CMediaRecognizer::ELocalAsxFile )

    {

        HandleMultiLinksFileL( aFileName, mediaType );

    }

    // check if this is a url eg. rtsp://someaddress/file.3gp

    //

    else if ( iRecognizer->IsValidStreamingPrefix(aFileName) )

    {

        HandleUrlDesL( aFileName );

    }

    else if ( mediaType == CMediaRecognizer::ELocalSdpFile )

    {

        iPlaybackUtility->InitStreamingL( aFileName,

                                         (TDesC8*)(&KDATATYPEVIDEOHELIX),

                                         iAccessPointId );

    }

    else

    {

        iPlaybackUtility->InitL( aFileName );

    }

    iRecognizer->FreeFilehandle();

}

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

// Open MPX media to player.

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

//

void CMpxVideoPlayerAppUiEngine::OpenMediaL( const CMPXMedia& aMedia )

{

    MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::OpenMediaL()"));

    // Assume MPX medias are always local clips

    CMPXCollectionPath* mediaPath = CMPXCollectionPath::NewL();

    CleanupStack::PushL( mediaPath );

    //

    // Workaround. Need a file like vcxmyvideosuids.h 

    //

    mediaPath->AppendL( 0x20016B97 );

    mediaPath->AppendL( KVcxMvcCategoryIdAll );

    mediaPath->AppendL( aMedia.ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId ) );

    mediaPath->SelectL( aMedia.ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId ) );

    CMPXCollectionPlaylist* playList = CMPXCollectionPlaylist::NewL( *mediaPath );

    CleanupStack::PushL( playList );

    playList->SetSingleItemPlaylist();

    playList->SetToFirst();

    LateInitL();

    iPlaybackUtility->InitL( *playList, ETrue );

    CleanupStack::PopAndDestroy( playList );

    CleanupStack::PopAndDestroy( mediaPath );

}

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

// Handle playback message.

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

//

void CMpxVideoPlayerAppUiEngine::DoHandlePlaybackMessageL( const CMPXMessage& aMessage )

{

    MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::DoHandlePlaybackMessageL()"));

    TMPXMessageId id( *aMessage.Value<TMPXMessageId>( KMPXMessageGeneralId ) );

    MPX_DEBUG(_L("CMpxVideoPlayerAppUiEngine::DoHandlePlaybackMessageL TMPXMessageId = 0x%08x"), id );

    if ( KMPXMessageGeneral == id )

    {

        TInt event( *aMessage.Value<TInt>( KMPXMessageGeneralEvent ) );

        MPX_DEBUG(_L("CMpxVideoPlayerAppUiEngine::DoHandlePlaybackMessageL() event = %d"), event);

        switch ( event )

        {

            case TMPXPlaybackMessage::EPlayerChanged:

            {

                MPX_DEBUG(_L("    EPlayerChanged"));

                if ( iUpdateSeekInfo )

                {

                    // The plugin has been instantiated, update the media

                    UpdatePbPluginMediaL();

                    iUpdateSeekInfo = EFalse;

                }

                HandlePlaybackPlayerChangedL();

                break;

            }

        }

    }

}

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

// Handle playback message for player changed.

// Activate the view which support this player

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

//

void CMpxVideoPlayerAppUiEngine::HandlePlaybackPlayerChangedL()

{

    MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::HandlePlaybackPlayerChangedL()"));

    ActivateVideoPlaybackView();

}

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

// Creates plugin resolver + creates & activates the video view

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

//

void CMpxVideoPlayerAppUiEngine::ActivateVideoPlaybackView()

{

    MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::ActivateVideoPlaybackView()"));

    iPlaybackWrapper->openPlaybackView();

}

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

// Closed mpx components and readies to application takedown.

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

//

void CMpxVideoPlayerAppUiEngine::PrepareCloseMpxL()

{

    MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::PrepareCloseMpxL()"));

    if ( iPlaybackUtility )

    {

        iPlaybackUtility->CommandL( EPbCmdClose );

        MMPXPlayerManager& manager = iPlaybackUtility->PlayerManager();

        TRAP_IGNORE( manager.ClearSelectPlayersL() );

    }

}

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

// Handle collection message

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

//

void CMpxVideoPlayerAppUiEngine::DoHandleCollectionMessageL( CMPXMessage* aMessage )

{

    MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::DoHandleCollectionMessageL()"));

    TMPXMessageId id = *(aMessage->Value<TMPXMessageId>( KMPXMessageGeneralId ));

    MPX_DEBUG(_L("CMpxVideoPlayerAppUiEngine::DoHandleCollectionMessageL() TMPXMessageId = 0x%08x"), id );

    if ( id == KMPXMessageGeneral )

    {

        TInt event( *( aMessage->Value<TInt> ( KMPXMessageGeneralEvent )) );

        TInt type( *( aMessage->Value<TInt> ( KMPXMessageGeneralType )) );

        TInt data( *( aMessage->Value<TInt> ( KMPXMessageGeneralData )) );

        MPX_DEBUG(_L("CMpxVideoPlayerAppUiEngine::DoHandleCollectionMessageL event %d, type %d, data %d"), event, type, data );

        if ( event == TMPXCollectionMessage::EPathChanged && type == EMcPathChangedByOpen )

        {

            if ( data == EMcItemOpened )

            {

                // An item was opened on the collection. Get the media attributes

                // on the item so we can initiatiate playback

                MPX_DEBUG(_L("CMpxVideoPlayerAppUiEngine::DoHandleCollectionMessageL: EMcItemOpened received. Can open video"));

                CMPXCollectionPath* cPath = iCollectionUtility->Collection().PathL();

                CleanupStack::PushL( cPath );

                if ( cPath->Count() > 0 )

                {

                    MPX_DEBUG(_L("CMpxVideoPlayerAppUiEngine::DoHandleCollectionMessageL: Call MediaL() on collection."));

                     RArray<TMPXAttribute> attribs;

                    CleanupClosePushL( attribs );

                    attribs.Append( KMPXMediaGeneralUri );

                    attribs.Append( KVcxMediaMyVideosDownloadId );

                    iCollectionUtility->Collection().MediaL( *cPath, attribs.Array() );

                    CleanupStack::PopAndDestroy( &attribs );

                }

                CleanupStack::PopAndDestroy( cPath );

            }

            else if ( data == EMcContainerOpened && iMultilinkPlaylist )

            {

                // start the playback for streaming playlists

                // once the playlist is opened

                iMultilinkPlaylist = EFalse;

                // The playlist was opened, initiatiate playback

                MPX_DEBUG(_L("CMpxVideoPlayerAppUiEngine::DoHandleCollectionMessageL: EMcContainerOpened received. initiatiate playback"));

                CMPXCollectionPath* cPath = iCollectionUtility->Collection().PathL();

                CleanupStack::PushL( cPath );

                if ( cPath->Count() > 0 )

                {

                    MPX_DEBUG(_L("CMpxVideoPlayerAppUiEngine::DoHandleCollectionMessageL: Call Playback utility with the playlist."));

                    CMPXCollectionPlaylist* playlist = CMPXCollectionPlaylist::NewL( *cPath );

                    CleanupStack::PushL( playlist );

                    // Set the AutoPlay mode to false

                    playlist->SetAutoPlay(EFalse);

                    // set pre init plugin to false

                    playlist->SetPreInitPlugin(EFalse);

                    iPlaybackUtility->InitL( *playlist, ETrue );

                    CleanupStack::PopAndDestroy( playlist );

                }

                CleanupStack::PopAndDestroy( cPath );

            }

        }

    }

}

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

// From MMPXCollectionObserver.

// Handle media properties.

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

//

void CMpxVideoPlayerAppUiEngine::DoHandelCollectionMediaL( const CMPXMedia& aMedia )

{

    MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::DoHandelCollectionMediaL()"));

    const TDesC& fileUri = aMedia.ValueText(KMPXMediaGeneralUri);

    MPX_DEBUG(_L("Video URI: %S"), &fileUri );

    //OpenMediaL( aMedia ); // Initialize and initiate playback of a single video

    LateInitL();

    TPtrC mediaFile( aMedia.ValueText( KMPXMediaGeneralUri ) );

    CMediaRecognizer::TMediaType mediaType = iRecognizer->IdentifyMediaTypeL(mediaFile);

    if ( mediaType == CMediaRecognizer::ELocalRamFile ||

         mediaType == CMediaRecognizer::ELocalAsxFile )

    {   

        HandleMultiLinksFileL( mediaFile, mediaType );

    }    

    else

    {

        OpenMediaL( aMedia ); // Initialize and initiate playback of a single video

    }    

}

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

//   CMpxVideoPlayerAppUiEngine::HandleMultiLinksFileL

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

//

void CMpxVideoPlayerAppUiEngine::HandleMultiLinksFileL( const TDesC& aFileName,

                                                        CMediaRecognizer::TMediaType aMediaType )

{

    MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::HandleMultiLinksFileL()"),

                   _L("aFileName = %S, type = %d"), &aFileName, aMediaType );

    TBool singleLink;

    TBool localFile;

    CVideoPlaylistUtility* playlistUtil = CVideoPlaylistUtility::NewL();