/*

* 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:  AppUI engine implementation

*

*/

#include <eikon.hrh>

#include <avkon.hrh>

#include <aknview.h>

#include <mpxviewutility.h>

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

#include <mpxcollectionpath.h>

#include <videoplayeractivationmessage.h>

#include <AiwGenericParam.h>

#include <mpxcollectionuihelper.h>

#include <mpxcollectionhelperfactory.h>

#include <mpxcollectionplugin.hrh>

#include <mpxmediageneralextdefs.h>

#include <streaminglinkmodel.h>

#include <coeutils.h>

#include <videoplaylistutility.h>

#include <mmf/common/mmfcontrollerframeworkbase.h>

#include "mpxvideoplayerappuiengine.h"

#include "mpxvideoplayerlogger.h"

#include "mpxvideoplayerconstants.h"

#include "mpxvideoembeddedpdlhandler.h"

#include <mpxvideoplaybackdefs.h>

#include "mpxvideo_debug.h"

#include "mpxvideoplayercustomviewmsgconsts.h"

const TInt KMpxPlaybackPluginTypeUid = 0x101FFCA0;

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

//   CMpxVideoPlayerAppUiEngine::CMpxVideoPlayerAppUiEngine

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

//

CMpxVideoPlayerAppUiEngine::CMpxVideoPlayerAppUiEngine( CMpxVideoPlayerAppUi* aAppUi )

    : iAppUi( aAppUi ),

      iPlaybackUtility( NULL ),

      iViewUtility( NULL ),

      iCollectionUtility( NULL ),

      iExitAo( NULL ),

      iRecognizer( NULL ),

      iAccessPointId( KUseDefaultIap ),

      iMultilinkPlaylist(EFalse),

      iSeekable(ETrue),

      iUpdateSeekInfo(EFalse)

{

}

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

//   CMpxVideoPlayerAppUiEngine::NewL

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

//

CMpxVideoPlayerAppUiEngine* CMpxVideoPlayerAppUiEngine::NewL( CMpxVideoPlayerAppUi* aAppUi )

{

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

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

}

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

//   CMpxVideoPlayerAppUiEngine::ConstructL

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

//

void CMpxVideoPlayerAppUiEngine::ConstructL()

{

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

    iRecognizer = CMediaRecognizer::NewL();

    //

    //  Create the View Utility

    //

    iViewUtility = MMPXViewUtility::UtilityL();

    iViewUtility->AddObserverL( this );

    iViewUtility->ConstructDefaultViewHistoryL();

    //

    //  Create the Collection Utility

    //

    if ( ! iAppUi->IsEmbedded() )

    {

        TUid collectionMode( KUidMpxVideoPlayerApplication );

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

    }

    //

    //  Create the playback utility to reduce startup time for embedded cases

    //

    else

    {

        PlaybackUtilityL();

    }

    //

    //  Create Active Object for exiting the application

    //

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

}

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

//   CMpxVideoPlayerAppUiEngine::PlaybackUtilityL

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

//

MMPXPlaybackUtility& CMpxVideoPlayerAppUiEngine::PlaybackUtilityL()

{

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

    if ( ! iPlaybackUtility )

    {

        //

        //  Create VideoHelix playback plugin

        //

        MMPXPlaybackUtility* playbackUtility =

            MMPXPlaybackUtility::UtilityL( EMPXCategoryVideo, KPbModeNewPlayer );

        MMPXPlayerManager& manager = playbackUtility->PlayerManager();

        TRAPD( err,

        {

            manager.SelectPlayerL( KVideoHelixPlaybackPluginUid );

            playbackUtility->CommandL( EPbCmdSetAutoResume, EFalse );

        } );

        if ( err == KErrNone )

        {

            iPlaybackUtility = playbackUtility;

        }

        else

        {

            TRAP_IGNORE( manager.ClearSelectPlayersL() );

            playbackUtility->Close();

            User::Leave( err );

        }

    }

    return *iPlaybackUtility;

}

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

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

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

//

void CMpxVideoPlayerAppUiEngine::PreLoadPdlPlaybackViewL()

{

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

    iViewUtility->PreLoadViewL( KVideoPdlPlaybackViewUid );

}

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

//   CMpxVideoPlayerAppUiEngine::~CMpxVideoPlayerAppUiEngine

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

//

CMpxVideoPlayerAppUiEngine::~CMpxVideoPlayerAppUiEngine()

{

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

    if ( iConstructTimer )

    {

        delete iConstructTimer;

        iConstructTimer = NULL;

    }

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

    {

        iViewUtility->RemoveObserver( this );

        iViewUtility->Close();

    }

    if ( iPlaybackUtility )

    {

        MMPXPlayerManager& manager = iPlaybackUtility->PlayerManager();

        TRAP_IGNORE( manager.ClearSelectPlayersL() );

        iPlaybackUtility->Close();

    }

}

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

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

        //

        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 )

        {

            PlaybackUtilityL().InitStreamingL( aFile, iAccessPointId );

            ActivatePlaybackViewL();

        }

        else

        {

            iViewUtility->PreLoadViewL( KVideoPlaybackViewUid );

            PlaybackUtilityL().InitL( aFile );

            ActivatePlaybackViewL();

        }

    }

    iRecognizer->FreeFilehandle();

    aFile.Close();

}

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

//   CMpxVideoPlayerAppUiEngine::OpenFileL

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

//

void CMpxVideoPlayerAppUiEngine::OpenFileL( const TDesC& aFileName )

{

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

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

    //

    //  pre load the view and initialize the playback framework

    //

    iViewUtility->PreLoadViewL( KVideoPlaybackViewUid );

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

    if ( mediaType == CMediaRecognizer::ELocalVideoFile )

    {

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

              mediaType == CMediaRecognizer::ELocalSdpFile )

    {

        InitializeStreamingLinkL( aFileName );

    }

    else

    {

        InitializeFileL( aFileName );

    }

    iRecognizer->FreeFilehandle();

}

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

//   CMpxVideoPlayerAppUiEngine::OpenMediaL()

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

//

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

    mediaPath->AppendL( KVcxUidMyVideosMpxCollection );

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

    iViewUtility->PreLoadViewL( KVideoPlaybackViewUid );

    InitializePlaylistL( *playList, ETrue );

    CleanupStack::PopAndDestroy( playList );

    CleanupStack::PopAndDestroy( mediaPath );

}

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

//   Activate the proper playback view

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

//

void CMpxVideoPlayerAppUiEngine::ActivatePlaybackViewL()

{

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

    if ( iUpdateSeekInfo )

    {

        //

        //  The plugin has been instantiated, update the media

        //

        UpdatePbPluginMediaL();

        iUpdateSeekInfo = EFalse;

    }

    MMPXPlayer* player = PlaybackUtilityL().PlayerManager().CurrentPlayer();

    TUid pluginUid( KNullUid );

    RArray<TUid> array;

    CleanupClosePushL( array );

    if ( iPdlHandler )

    {

        array.AppendL( KVideoPdlPlaybackViewUid );

    }

    else

    {

        if ( player )

        {

            pluginUid = player->UidL();

            array.AppendL( pluginUid );

        }

    }

    iViewUtility->ActivateViewL( array );

    CleanupStack::PopAndDestroy( &array );

}

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

// Sets AppUiEngine in stand alone "mode"

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

//

void CMpxVideoPlayerAppUiEngine::StartStandAloneL()