/*

* 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:  This class plays local video file

 *

*/

// Version : %version: 11 %

//

//  INCLUDE FILES

//

#include <apgcli.h>

#include <e32cmn.h>

#include <mpxcenrepwatcher.h>

#include <mpxcenrepobserver.h>

#include <mpxmediageneraldefs.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxplaybackcommanddefs.h>

#include <mmf/server/mmffile.h>

#include "mpxvideohelixplayback.h"

#include "mpxvideoprivatecrkeys.h"

#include <mpxvideoplaybackdefs.h>

//

//  CONSTANTS

//

const TUid KLocalPlaybackUid = { 0x10282551 };

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

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

//    Two-phased constructor.

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

//

CMPXVideoHelixPlayback* CMPXVideoHelixPlayback::NewL( TAny* /*aInitParams*/ )

{

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

    CMPXVideoHelixPlayback* p = new (ELeave) CMPXVideoHelixPlayback();

    CleanupStack::PushL(p);

    p->ConstructL();

    CleanupStack::Pop(p);

    return p;

}

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

//    Symbian 2nd phase constructor can leave.

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

//

void CMPXVideoHelixPlayback::ConstructL()

{

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

    iVideoPlaybackCtlr = CMPXVideoPlaybackController::NewL( *iObs );

    User::LeaveIfError( iFs.Connect() );

    iFs.ShareProtected();

}

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

//    C++ constructor

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

//

CMPXVideoHelixPlayback::CMPXVideoHelixPlayback()

{

    MPX_DEBUG(_L("CMPXVideoHelixPlayback::CMPXVideoHelixPlayback()"));

}

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

//    Destructor

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

//

CMPXVideoHelixPlayback::~CMPXVideoHelixPlayback()

{

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

    iFs.Close();

    if ( iVideoPlaybackCtlr )

    {

        delete iVideoPlaybackCtlr;

        iVideoPlaybackCtlr = NULL;

    }

}

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

//    Sets the file name and file handle

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

//

void CMPXVideoHelixPlayback::OpenFileHandleL( const TDesC& aUri, RFile& aFile )

{

    MPX_ENTER_EXIT(

            _L("CMPXVideoHelixPlayback::OpenFileHandleL( RFile )"),

            _L("aSong %S"), &aUri );

    if ( aFile.SubSessionHandle() )

    {

        aFile.Close();

    }

    TInt err = aFile.Open( iFs, aUri, EFileRead | EFileShareReadersOrWriters );

    HandleOpenFileHandleL( err );

}

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

//    Initializes a clip for playback from a file name

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

//

void CMPXVideoHelixPlayback::InitialiseL( const TDesC& aSong )

{

    MPX_ENTER_EXIT(_L("CMPXVideoHelixPlayback::InitialiseL()"),

                   _L("aSong %S"), &aSong );

    RFile fileHandle;

    CleanupClosePushL( fileHandle );

    MPX_TRAPD( err, OpenFileHandleL( aSong, fileHandle ));

    if ( err == KErrNone )

    {

        iVideoPlaybackCtlr->OpenFileL( aSong, fileHandle );

    }   

#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

    else if ( err == KErrTooBig )

    {

        // 

        // use RFile64 handle

        //

        RFile64 fileHandle64;

        CleanupClosePushL( fileHandle64 );

        MPX_TRAPD( err, OpenFileHandle64L( aSong, fileHandle64 ));

        if ( err != KErrNone )

        {

            // Handle error

            iVideoPlaybackCtlr->HandleError( err );

        }

        else

        {

            iVideoPlaybackCtlr->OpenFile64L( aSong, fileHandle64 );

        }

        CleanupStack::PopAndDestroy(); // fileHandle64        

    }

#endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

    else

    {

        // Handle error

        iVideoPlaybackCtlr->HandleError( err );        

    }

    CleanupStack::PopAndDestroy(); // fileHandle

}

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

//    Initializes a clip for playback from a file handle

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

//

void CMPXVideoHelixPlayback::InitialiseL( RFile& aSong )

{

    MPX_ENTER_EXIT(_L("CMPXVideoHelixPlayback::InitialiseL( RFile )"));

    TFileName filename;

    aSong.FullName( filename );

    iVideoPlaybackCtlr->OpenFileL( filename, aSong );

}

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

//    Initializes a clip for playback from a file name

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

//

void CMPXVideoHelixPlayback::InitStreamingL( const TDesC& aUri,

                                             const TDesC8& /*aType*/,

                                             TInt aAccessPoint )

{

    MPX_ENTER_EXIT(_L("CMPXVideoHelixPlayback::InitStreamingL()"),

                   _L("aUri %S, aType %d"), &aUri, aAccessPoint );

    RFile fileHandle;

    CleanupClosePushL( fileHandle );

    MPX_TRAPD( err, OpenFileHandleL( aUri, fileHandle ));

    if ( err != KErrNone )

    {

        // Handle error

        iVideoPlaybackCtlr->HandleError( err );

    }

    else

    {

        iVideoPlaybackCtlr->OpenFileL( aUri, fileHandle, aAccessPoint );

    }

    CleanupStack::PopAndDestroy();

}

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

//    Initializes a clip for playback from a file handle

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

//

void CMPXVideoHelixPlayback::InitStreamingL( RFile& aFile, TInt aAccessPoint  )

{

    MPX_ENTER_EXIT(_L("CMPXVideoHelixPlayback::InitStreamingL( RFile )"));

    TFileName filename;

    aFile.FullName( filename );

    iVideoPlaybackCtlr->OpenFileL( filename, aFile, aAccessPoint );

}

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

//    Executes a command on the selected song

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

//

void CMPXVideoHelixPlayback::CommandL( CMPXCommand& aCmd )

{

    MPX_ENTER_EXIT(_L("CMPXVideoHelixPlayback::CommandL() - CMPXCommand"));

    iVideoPlaybackCtlr->HandleCommandL( aCmd );

}

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

//    Executes a command on the selected song

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

//

void CMPXVideoHelixPlayback::CommandL(TMPXPlaybackCommand aCmd, TInt aData)

{

    MPX_ENTER_EXIT(_L("CMPXVideoHelixPlayback::CommandL() - TMPXPlaybackCommand"));

    iVideoPlaybackCtlr->HandleCommandL(aCmd, aData);

}

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

//    Sets a property of the plugin

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

//

void CMPXVideoHelixPlayback::SetL( TMPXPlaybackProperty aProperty, TInt aValue )

{

    MPX_ENTER_EXIT(_L("CMPXVideoHelixPlayback::SetL()"));

    // Route the SetL() to VideoPlaybackController

    iVideoPlaybackCtlr->SetPropertyL(aProperty, aValue);

}

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

//    Gets a property of the plugin (async)

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

//

void CMPXVideoHelixPlayback::PropertyL( TMPXPlaybackProperty aProperty ) const

{

    MPX_ENTER_EXIT(_L("CMPXVideoHelixPlayback::PropertyL()"));

    // Route the PropertyL() to VideoPlaybackController

    iVideoPlaybackCtlr->GetPropertyL( aProperty );

}

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

//    Gets a list of sub players, UPnP only

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

//

void CMPXVideoHelixPlayback::SubPlayerNamesL()

{

    MPX_ENTER_EXIT(_L("CMPXVideoHelixPlayback::SubPlayerNamesL()"));

    iObs->HandleSubPlayerNames( KLocalPlaybackUid, NULL, ETrue, KErrNone );

}

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

//    Select a sub player

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

//

void CMPXVideoHelixPlayback::SelectSubPlayerL( TInt /*aIndex*/ )

{

    MPX_ENTER_EXIT(_L("CMPXVideoHelixPlayback::SelectSubPlayerL()"));

    User::Leave( KErrNotSupported );

}

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

//    Gets media properties

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

//

void CMPXVideoHelixPlayback::MediaL( const TArray<TMPXAttribute>& aAttrs )

{

    MPX_ENTER_EXIT(_L("CMPXVideoHelixPlayback::MediaL()"));

    iVideoPlaybackCtlr->SendMediaL( aAttrs );

}

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

//    Cancel request

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

//

void CMPXVideoHelixPlayback::CancelRequest()

{

    MPX_ENTER_EXIT(_L("CMPXVideoHelixPlayback::CancelRequest()"));

}

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

//    Handle Open File Handle

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

//

void CMPXVideoHelixPlayback::HandleOpenFileHandleL( TInt aError )

{

    MPX_ENTER_EXIT(_L("CMPXVideoHelixPlayback::HandleOpenFileHandleL()"));

    //

    //  Remap KErrNotReady to KErrNotFound, because it is referencing a drive

    //  that is not existent

    //

    if ( aError == KErrNotReady )

    {

        aError = KErrNotFound;

    }

    MPX_DEBUG(_L("CMPXVideoHelixPlayback::HandleOpenFileHandleL() Open error = %d"), aError);

    //

    //  if aSong is an streaming link and contains one of the streaming schemas

    //  eg. rtsp:// , http:// etc. then a file handle can not be opened

    //  ignore KErrBadName

    //

    if ( aError != KErrBadName )

    {

        User::LeaveIfError( aError );

    }

}

#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

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

//    Sets the file name and 64-bit file handle

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

//

void CMPXVideoHelixPlayback::OpenFileHandle64L( const TDesC& aUri, RFile64& aFile )

{

    MPX_ENTER_EXIT(

            _L("CMPXVideoHelixPlayback::OpenFileHandle64L( RFile64 )"),

            _L("aSong %S"), &aUri );

    if ( aFile.SubSessionHandle() )

    {

        aFile.Close();

    }

    TInt err = aFile.Open( iFs, aUri, EFileRead | EFileShareReadersOrWriters );

    HandleOpenFileHandleL( err );

}

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

//    Initializes a clip for playback from a 64-bit file handle

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

//

void CMPXVideoHelixPlayback::Initialise64L( RFile64& aSong )

{

    MPX_ENTER_EXIT(_L("CMPXVideoHelixPlayback::Initialise64L( RFile64 )"));

    TFileName filename;

    aSong.FullName( filename );

    iVideoPlaybackCtlr->OpenFile64L( filename, aSong );

}

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

//    Initializes a clip for playback from a 64-bit file handle

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

//

void CMPXVideoHelixPlayback::InitStreaming64L( RFile64& aFile, TInt aAccessPoint  )

{

    MPX_ENTER_EXIT(_L("CMPXVideoHelixPlayback::InitStreaming64L( RFile64 )"));

    TFileName filename;

    aFile.FullName( filename );

    iVideoPlaybackCtlr->OpenFile64L( filename, aFile, aAccessPoint );

}

#endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

// End of file