/*

* 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

 *

*/

// Version : %version:  5 %

#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 <AiwGenericParam.h>

#include <mpxcollectionuihelper.h>

#include <mpxcollectionhelperfactory.h>

#include <mpxcollectionplugin.hrh>

#include <mpxmediageneralextdefs.h>

#include <mmf/common/mmfcontrollerframeworkbase.h>

#include <streaminglinkmodel.h>

#include <coeutils.h>

#include <videoplaylistutility.h>

#include <mpxvideoplaybackdefs.h>

#include "mpxvideoplayerappuiengine.h"

#include "mpxvideoplayerconstants.h"

#include "mpxvideoembeddedpdlhandler.h"

#include "mpxvideoplaybackwrapper.h"

#include "mpxhbvideocommondefs.h"

#include "mpxvideo_debug.h"

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

//   CMpxVideoPlayerAppUiEngine::CMpxVideoPlayerAppUiEngine

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

//

CMpxVideoPlayerAppUiEngine::CMpxVideoPlayerAppUiEngine( QMpxVideoPlaybackWrapper* aWrapper )

    : iPlaybackUtility( NULL ),

      iCollectionUtility( NULL ),

      iExitAo( NULL ),

      iRecognizer( NULL ),

      iAccessPointId( KUseDefaultIap ),

      iMultilinkPlaylist( EFalse ),

      iSeekable( ETrue ),

      iUpdateSeekInfo( EFalse ),

      iPlaybackWrapper( aWrapper )

{

}

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

//   CMpxVideoPlayerAppUiEngine::NewL

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

//

CMpxVideoPlayerAppUiEngine* CMpxVideoPlayerAppUiEngine::NewL( QMpxVideoPlaybackWrapper* aWrapper )

{

    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()

{	       

    CreatePlaybackUtilityMemberVariablesL();

    iRecognizer = CMediaRecognizer::NewL();

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

}

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

//   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::CreatePlaybackUtilityMemberVariablesL

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

//

void CMpxVideoPlayerAppUiEngine::CreatePlaybackUtilityMemberVariablesL()

{

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

    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::CreateEmbeddedPdlPlaybackUtilityMemberVariablesL

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

//

void CMpxVideoPlayerAppUiEngine::CreateEmbeddedPdlPlaybackUtilityMemberVariablesL()

{

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

	  CreatePlaybackUtilityMemberVariablesL();

}

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

//   CMpxVideoPlayerAppUiEngine::~CMpxVideoPlayerAppUiEngine

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

//

CMpxVideoPlayerAppUiEngine::~CMpxVideoPlayerAppUiEngine()

{

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

    if ( iExitAo )

    {

        delete iExitAo;

        iExitAo = NULL;

    }

    if ( iRecognizer )

    {

        delete iRecognizer;

        iRecognizer = NULL;

    }

    if ( iPdlHandler )

    {

        delete iPdlHandler;

        iPdlHandler = 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::HandleAiwGenericParamListL()

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

//

TInt CMpxVideoPlayerAppUiEngine::HandleAiwGenericParamListL( const CAiwGenericParamList* aParams )

{

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

    TInt retVal = KErrNone;

    TInt index = 0;

    //

    //  Check if there is a terminate message.  If it exists, exit the application.

    //

    TInt32 terminateID = 0;

    const TAiwGenericParam* paramTerminate =

        aParams->FindFirst( index, EGenericParamTerminate, EVariantTypeTInt32 );

    if ( paramTerminate )

    {

        paramTerminate->Value().Get( terminateID );

    }

    if ( terminateID )

    {

        MPX_DEBUG(_L("CMpxVideoPlayerAppUiEngine::HandleAiwGenericParamListL()  Terminate message received"));

        //

        //  Embedded app is being closed

        //

        //

        // Workaround. Will handle it once AIW gets supported

        //

        //iAppUi->HandleCommandL( EEikCmdExit );

        retVal = KErrCancel;

    }

    else

    {

        //

        //  Determine if these parameters are for PDL

        //

        index = 0;

        TInt32 dlId = KErrNotFound;

        const TAiwGenericParam* genParamDlId =

            aParams->FindFirst( index, EGenericParamDownloadId, EVariantTypeTInt32 );

        if ( genParamDlId )

        {

            genParamDlId->Value().Get( dlId );

            index = 0;

            const TAiwGenericParam* paramFileName =

                aParams->FindFirst( index, EGenericParamFile, EVariantTypeDesC );

            TPtrC fileName;

            //

            //  Set the filename.  The LWPlayerAppUi checks for the

            //  filename and exits if it doesn't exist

            //

            fileName.Set( paramFileName->Value().AsDes() );

            if ( ! iPdlHandler )

            {

                iPdlHandler = CMpxVideoEmbeddedPdlHandler::NewL( this );

            }

            iPdlHandler->ConnectToEmbeddedDownloadL( dlId, fileName );

        }

        else

        {

            //

            //  Check Access Point

            //

            index = 0;

            const TAiwGenericParam* genParamAccessPoint =

                aParams->FindFirst( index, EGenericParamAccessPoint, EVariantTypeTInt32 );

            if ( index >= 0 && genParamAccessPoint )

            {

                TInt32 apId = KErrUnknown;

                genParamAccessPoint->Value().Get( apId );

                iAccessPointId = apId;

            }

        }

    }

    return retVal;

}

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

//   CMpxVideoPlayerAppUiEngine::OpenFileL

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

//

void CMpxVideoPlayerAppUiEngine::OpenFileL( RFile& aFile, const CAiwGenericParamList* aParams )

{

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

    TInt err = KErrNone;

    if ( aParams )

    {

        err = HandleAiwGenericParamListL( aParams );

    }

    if ( KErrNone == err && ! iPdlHandler )

    {

        TFileName filename;

        aFile.FullName(filename);

        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);

    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();

    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() );

    }

}

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

// Sets AppUiEngine in stand alone "mode"

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

//

void CMpxVideoPlayerAppUiEngine::StartStandAloneL()

{

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