/*

* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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 the CMPFileDetailsDialog.*

*/

// INCLUDE FILES

#include <aknlists.h>

#include <bautils.h>

#include <StringLoader.h>

#include <e32base.h>

#include <utf.h>

#include <mmf/common/mmferrors.h>

#include <DRMHelper.h>

#include <aknclearer.h>

#include <e32math.h> //for size rounding

#include <MPFileDetails.rsg>

#include "mpxvideo_debug.h"

#include <AiwServiceHandler.h>

#include <AiwCdmaCommands.hrh>

#include <featmgr.h>

#include <data_caging_path_literals.hrh> // KDC_RESOURCE_FILES_DIR

#include <centralrepository.h>

#include "MediaPlayerVariant.hrh"

#include <MetaDataUtility.h>

#include <MetaDataFieldContainer.h>

#include <caf/content.h>

#include <Oma2Agent.h>

#include "MediaPlayerPrivateCRKeys.h"

#include "MPFileDetailsDialog.h"

#include "mppopuplist.h"

#include <mediarecognizer.h>

#include <streaminglinkmodel.h>

#include "MPFileDetails.h"

#include "MediaPlayerDrmHelper.h"

//

//  Inline methods

//

#include "MPFileDetailsDialog.inl"

//#include "MPAppConsts.h"

#include <drmutility.h>

#ifdef __WINDOWS_MEDIA

#include <asxparser.h>

#endif

// CONSTANTS

_LIT(KResourceFile,"z:MPFileDetails.rsc");

const TInt KOneKilobyte = 1;

const TInt KFileSizeOneKilobyte = 1024;

const TInt KThousandNotKilobyte = 1000;

const TInt KOneSecond(1000000);

const TInt KOneHourInSeconds(3600);

const TInt KMaxTimeLength = 36;

const TInt KMaxFilePathLength = 2048;

// For meta data

_LIT( KMPTitle, "Title" );

_LIT( KMPArtist, "Artist" );

_LIT( KMPAuthor, "Author" );

_LIT( KMPCopyright, "Copyright" );

_LIT( KMPAbstract, "Abstract" );

_LIT( KExt3gpp,     "3gp" );

_LIT( KExtMp4,      "mp4" );

_LIT( KExtM4a,      "m4a" );

_LIT(KDetaMime3gpp,  "audio/3gpp");

_LIT(KDetaMime3gpp2, "audio/3gpp2");

_LIT(KDetaMimeMp4,   "audio/mp4");

_LIT(KFormat,"MimeType");

_LIT(KMPX,   "x");

// ================= OTHER EXPORTED FUNCTIONS ==============

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

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

// CMPFileDetailsDialog::CMPFileDetailsDialog

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CMPFileDetailsDialog::CMPFileDetailsDialog()

    : iResourceFileOffset(0)

    , iResult( KErrNone )

{

    MPX_ENTER_EXIT(_L("CMPFileDetailsDialog::CMPFileDetailsDialog()"));

}

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

// CMPFileDetailsDialog::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CMPFileDetailsDialog::ConstructL()

{

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

    LoadResourcesL();

    iListBox = new (ELeave) CAknDoublePopupMenuStyleListBox();

    iGenres = CCoeEnv::Static()->ReadDesCArrayResourceL( R_MP_GENRE_STRINGS );

}

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

// CMPFileDetailsDialog::NewL

// Two-phased constructor.

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

//

EXPORT_C CMPFileDetailsDialog* CMPFileDetailsDialog::NewL()

{

    MPX_ENTER_EXIT(_L("CMPFileDetailsDialog* CMPFileDetailsDialog::NewL()"));

    CMPFileDetailsDialog* self = new( ELeave ) CMPFileDetailsDialog();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

}

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

// CMPFileDetailsDialog::~CMPFileDetailsDialog

// Destructor

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

//

EXPORT_C CMPFileDetailsDialog::~CMPFileDetailsDialog()

{

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

    if( iPopupList )

        {

        iPopupList->CancelPopup();

        }

    delete iListBox;

    delete iGenres;

    UnLoadResources();

}

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

// CMPFileDetailsDialog::ExecuteLD

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

//

EXPORT_C void CMPFileDetailsDialog::ExecuteLD(const TDesC& aFileName)

{

    MPX_ENTER_EXIT(_L("CMPFileDetailsDialog::ExecuteLD()"));

    CleanupStack::PushL( this );

    CMPFileDetails* fileDetails = new (ELeave) CMPFileDetails();

    CleanupStack::PushL( fileDetails );

	//

	// Obtain file path first so it can be used later

	//

    fileDetails->iFilePath = aFileName.AllocL();

#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

    RFile64 fileHandle;

#else

    RFile fileHandle;

#endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

    TUint fileMode = EFileShareReadersOrWriters | EFileStream | EFileRead;

    RFs fs = CEikonEnv::Static()->FsSession();

    User::LeaveIfError(fileHandle.Open(fs, aFileName, fileMode));

    CleanupClosePushL(fileHandle);

    DRM::CDrmUtility* drmUtil = DRM::CDrmUtility::NewLC();

    TRAP_IGNORE( fileDetails->iDrmProtected =

        drmUtil->IsProtectedL(fileHandle) );

    CleanupStack::PopAndDestroy(2); // fileHandle, drmUtil

    if ( fileDetails->iDrmProtected )

        {

        //

		// All DRM rights are handled & displayed by DRM component.

        // MP only needs to display DCF header info (Title, Provider, Description).

        //

        FetchDCFHeaderDataL(aFileName, fileDetails);

        }

    // recognize file and get format

    CMediaRecognizer* recognizer = CMediaRecognizer::NewL();

    CleanupStack::PushL(recognizer);

    CMediaRecognizer::TMediaType mediaType =

                recognizer->IdentifyMediaTypeL( aFileName, ETrue );

    // mime type not shown for playlists and ram files

    if ( mediaType != CMediaRecognizer::ELocalRamFile &&

         mediaType != CMediaRecognizer::ELocalAsxFile &&

         mediaType != CMediaRecognizer::ELocalAudioPlaylist )

        {

        fileDetails->iFormat = recognizer->MimeTypeL( aFileName ).AllocL();

        }

    CleanupStack::PopAndDestroy();  // recognizer

    // filename

    TParse parse;

    parse.Set(aFileName,NULL,NULL);

    fileDetails->iFileName = parse.Name().AllocL();

    switch (mediaType)

        {

        case CMediaRecognizer::ELocalVideoFile:

            {

#ifdef SYMBIAN_BUILD_GCE

            CVideoPlayerUtility2* videoPlayer = CVideoPlayerUtility2::NewL(*this,

                EMdaPriorityNormal,EMdaPriorityPreferenceNone );

#else

            CMPDummyController* dummy = CMPDummyController::NewLC();

            TRect tmp;

            CVideoPlayerUtility* videoPlayer = CVideoPlayerUtility::NewL(*this,

                            EMdaPriorityNormal,EMdaPriorityPreferenceNone,

                            dummy->GetClientWsSession(),dummy->GetScreenDevice(),

                            dummy->GetClientWindow(),tmp,tmp);

#endif // SYMBIAN_BUILD_GCE

            CleanupStack::PushL(videoPlayer);

            // open

            videoPlayer->OpenFileL(aFileName);

            // wait open to complete

            iWait.Start();

            if (iResult && iResult != KErrMMPartialPlayback)

                {

#ifdef SYMBIAN_BUILD_GCE

                CleanupStack::PopAndDestroy(1); // videoPlayer

#else

                CleanupStack::PopAndDestroy(2); // dummy and videoPlayer

#endif //SYMBIAN_BUILD_GCE

                break;

                }

            // prepare

            videoPlayer->Prepare();

            // wait prepare to complete

            iWait.Start();

            if (iResult && iResult != KErrMMPartialPlayback)

                {

#ifdef SYMBIAN_BUILD_GCE

                CleanupStack::PopAndDestroy(1); // videoPlayer

#else

                CleanupStack::PopAndDestroy(2); // dummy and videoPlayer

#endif //SYMBIAN_BUILD_GCE

                break;

                }

            // get video file details

            // duration

            fileDetails->iDurationInSeconds =

                    videoPlayer->DurationL().Int64() / KOneSecond;

            // resolution

            TSize size;

            videoPlayer->VideoFrameSizeL(size);

            fileDetails->iResolutionHeight = size.iHeight;

            fileDetails->iResolutionWidth = size.iWidth;

            // bitrate

            fileDetails->iBitrate = videoPlayer->VideoBitRateL() +

                                    videoPlayer->AudioBitRateL();

            // video track

            fileDetails->iVideoTrack = videoPlayer->VideoBitRateL();

            TPtrC8 videoFormat = videoPlayer->VideoFormatMimeType();

            delete fileDetails->iFormat;

            fileDetails->iFormat = NULL;

            if ( videoFormat.Length())

            {

                HBufC* videoFormat16 = HBufC::NewLC(videoFormat.Length());

                TPtr videoFormatDes16(videoFormat16->Des());

                videoFormatDes16.Copy(videoFormat);

                fileDetails->iFormat = videoFormatDes16.AllocL();

                CleanupStack::PopAndDestroy();   //videoFormat16

            }

            // copyright & title & format

            TInt metaCount = videoPlayer->NumberOfMetaDataEntriesL();

            CMMFMetaDataEntry* metaData;

            for (TInt i = 0; i < metaCount; i++)

                {

                metaData = videoPlayer->MetaDataEntryL(i);

                if (!metaData->Name().CompareF(KMPCopyright))

                    {

                    fileDetails->iCopyright = metaData->Value().AllocL();

                    }

                else if (!metaData->Name().CompareF(KMPArtist) || !metaData->Name().Compare(KMPAuthor))

                    {

                    fileDetails->iArtist = metaData->Value().Alloc();

                    }

                else if (!metaData->Name().CompareF(KMPTitle))

                    {

                    fileDetails->iTitle = metaData->Value().AllocL();

                    }

                else if (!metaData->Name().CompareF(KMPAbstract))

                     {

                          fileDetails->iDescription = metaData->Value().AllocL();

                     }

                else if (!(metaData->Name().CompareF(KFormat) || fileDetails->iFormat))

                     {

                          fileDetails->iFormat = metaData->Value().AllocL();

                     }

                delete metaData;

                }

#ifdef SYMBIAN_BUILD_GCE

            CleanupStack::PopAndDestroy(1); // videoPlayer

#else

            CleanupStack::PopAndDestroy(2); // dummy and videoPlayer

#endif //SYMBIAN_BUILD_GCE

            }

            break;

        case CMediaRecognizer::ELocalRamFile:

            {

            // get first link

            CStreamingLinkModel* linkModel = CStreamingLinkModel::NewL();

            CleanupStack::PushL(linkModel);

            User::LeaveIfError(linkModel->OpenLinkFileL( aFileName, EFalse ));

            fileDetails->iUrl = HBufC::NewL(linkModel->MaxLinkLength());

            TPtr filePtr = fileDetails->iUrl->Des();

            TBool dummy;

            linkModel->GetNextLinkL(filePtr,dummy);

            CleanupStack::PopAndDestroy(); // linkModel

            }

            break;

        case CMediaRecognizer::ELocalAsxFile:

            {

#ifdef __WINDOWS_MEDIA

			CAsxParser* asxParser = NULL;

			TRAPD(err, asxParser = CAsxParser::NewL( aFileName ));

			CleanupStack::PushL( asxParser );

			if ( !err && asxParser && asxParser->FileVersion() > 0 )

				{

				TUint asxUrlCount = 0;

				TPtrC8 urlPtr;

				asxParser->GetUrlCount(asxUrlCount);

				if ( asxUrlCount )

					{

					// get first link

					asxParser->GetUrl(1,urlPtr);

					fileDetails->iUrl = HBufC::NewL(urlPtr.Length());

					TPtr filePtr = fileDetails->iUrl->Des();

					asxParser->PrintUrl(urlPtr,filePtr);

					}

				}

			CleanupStack::PopAndDestroy();  // asxparser

#endif

            }

            break;

        case CMediaRecognizer::ELocalAudioFile:

            {

            FetchMetaDataL( aFileName, fileDetails );

            }

            break;

        default:

            break;

        }

    if (mediaType != CMediaRecognizer::ELocalRamFile &&

		mediaType != CMediaRecognizer::ELocalAsxFile )

        {

        RFs fs = CEikonEnv::Static()->FsSession();

#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

        RFile64 file; 

#else

        RFile file;

#endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

        TInt error = file.Open(fs, aFileName, EFileRead | EFileShareReadersOnly);

        if (error)

            {

            // Try different sharing method if the first one failed.

            error = file.Open(fs, aFileName, EFileRead | EFileShareAny);

            }

        if (!error)

            {

            // Set item size, ignore error code

            if (mediaType != CMediaRecognizer::ELocalAudioPlaylist)

                {

                file.Size(fileDetails->iSize);

                }

            // Set modification date & time, ignore error code

            file.Modified(fileDetails->iTime);

            file.Close();

            }

        }

    // Show File Details in differend ExecuteLD

    ExecuteLD( fileDetails );

    CleanupStack::PopAndDestroy(); // fileDetails

    CleanupStack::Pop(); // this

}

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

// CMPFileDetailsDialog::ExecuteLD

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

//

EXPORT_C void CMPFileDetailsDialog::ExecuteLD(CMPFileDetails* aFileDetails)

{

    MPX_ENTER_EXIT(_L("CMPFileDetailsDialog::ExecuteLD()"));

    if ( aFileDetails->iDrmProtected && aFileDetails->iFilePath )

    {

        // drm data

        FetchDrmDataL( *aFileDetails->iFilePath, aFileDetails );

    }

    if ( iPopupList )

    {

        iPopupList->CancelPopup();

        iPopupList = NULL;

    }

    //

    //  use Media Player's own PopupList, not Avkon's PopupList

    //

#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

    TInt64 size(0);

#else

    TInt size(0);

#endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

    TInt error(0);

    TInt handleExists(0);

    if (  aFileDetails->iDetailsFileHandle.SubSessionHandle() )

    {

        error = aFileDetails->iDetailsFileHandle.Size( size );

    }

    handleExists =(!error && size )? ETrue:EFalse;

    if( handleExists )

    {

        iPopupList = CMPPopupList::NewL( iListBox,

                                         aFileDetails->iDetailsFileHandle,

                                         aFileDetails->iDrmProtected,

                                         aFileDetails->iReadingDCFOnly );

    }

    else

    {

        //

        //  file path is not available when this ExecuteLD(aFileDetails) method is

        //	launched by MP Video View for streaming link. Hence, this value is set

        //  to Null in such case.

        //

        HBufC* temp = HBufC::NewL(KMaxFilePathLength);

        CleanupStack::PushL( temp );

        TPtr filePathPtr = temp->Des();

        if ( aFileDetails->iFilePath )

        {

            filePathPtr.Append( aFileDetails->iFilePath->Des() );

        }

        else

        {

            filePathPtr.Append( KNullDesC() );

        }

        //

        //  use Media Player's own PopupList, not Avkon's PopupList

        //

        iPopupList = CMPPopupList::NewL( iListBox,

                                     filePathPtr,

                                     aFileDetails->iDrmProtected,

                                     aFileDetails->iReadingDCFOnly );

        CleanupStack::PopAndDestroy( temp );

    }

    TRAPD( err,

    {

        iListBox->ConstructL(iPopupList, CEikListBox::EDisableHighlight );

        iListBox->ItemDrawer()->ColumnData()->EnableMarqueeL( ETrue );

        iListBox->CreateScrollBarFrameL(ETrue);

        iListBox->ScrollBarFrame()->

            SetScrollBarVisibilityL( CEikScrollBarFrame::EOff,

                                     CEikScrollBarFrame::EAuto );

        SetTitleL(iPopupList);

        FillListBoxL(aFileDetails);

        iPopupList->ExecuteLD();

        iPopupList = NULL;

    } );//TRAP

	//explicitly cancel the Popup if it's not terminated properly

    if ( err && iPopupList )

    {

        iPopupList->CancelPopup();

        iPopupList = NULL;

    }

    delete this;

}

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

// CMPFileDetailsDialog::UnLoadResourceFile

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

//

void CMPFileDetailsDialog::UnLoadResources()

{