/*

* Copyright (c) 2007-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:  Harvests metadata from rtp video file 

*

*/

#include <e32std.h>

#include <apgcli.h> 

#include "harvesterdata.h"

#include "harvesterrtpplugin.h"

#include "harvesterlog.h"

#include "mdeobject.h"

#include "mdsutils.h"

#include "harvestercommon.h"

#include "mdeobjectwrapper.h"

#include "harvesterrtpmetadatareader.h"

#include <mdenamespacedef.h>

#include <mdeobjectdef.h>

// Supported mime type

_LIT( KRtpClipMimetype, "application/x-nokia-teh-rtp" );

// Enough size to recognize file and read metaheader

const TInt KFileBufferSize( KMaxMetaHeaderLength );

CHarvesterRtpPluginPropertyDefs::CHarvesterRtpPluginPropertyDefs() : CBase()

	{

	}

void CHarvesterRtpPluginPropertyDefs::ConstructL(CMdEObjectDef& aObjectDef)

	{

	CMdENamespaceDef& nsDef = aObjectDef.NamespaceDef();

	// Common property definitions

	CMdEObjectDef& objectDef = nsDef.GetObjectDefL( MdeConstants::Object::KBaseObject );

	iCreationDatePropertyDef = &objectDef.GetPropertyDefL( MdeConstants::Object::KCreationDateProperty );

	iLastModifiedDatePropertyDef = &objectDef.GetPropertyDefL( MdeConstants::Object::KLastModifiedDateProperty );

	iSizePropertyDef = &objectDef.GetPropertyDefL( MdeConstants::Object::KSizeProperty );

	iItemTypePropertyDef = &objectDef.GetPropertyDefL( MdeConstants::Object::KItemTypeProperty );

	iTitlePropertyDef = &objectDef.GetPropertyDefL( MdeConstants::Object::KTitleProperty );

	CMdEObjectDef& mediaDef = nsDef.GetObjectDefL( MdeConstants::MediaObject::KMediaObject );

	iCaptureDatePropertyDef =& mediaDef.GetPropertyDefL( MdeConstants::MediaObject::KCaptureDateProperty );

	iDurationPropertyDef = &mediaDef.GetPropertyDefL( MdeConstants::MediaObject::KDurationProperty );

	CMdEObjectDef& videoDef = nsDef.GetObjectDefL( MdeConstants::Video::KVideoObject );

	iAgeProfilePropertyDef = &videoDef.GetPropertyDefL( MdeConstants::Video::KAgeProfileProperty );

	iRecordingFlagsPropertyDef = &videoDef.GetPropertyDefL( MdeConstants::Video::KRecordingFlagsProperty );

	}

CHarvesterRtpPluginPropertyDefs* CHarvesterRtpPluginPropertyDefs::NewL(CMdEObjectDef& aObjectDef)

	{

	CHarvesterRtpPluginPropertyDefs* self = 

		new (ELeave) CHarvesterRtpPluginPropertyDefs();

	CleanupStack::PushL( self );

	self->ConstructL( aObjectDef );

	CleanupStack::Pop( self );

	return self;

	}

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

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

// Default constructor

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

//

CHarvesterRtpPlugin::CHarvesterRtpPlugin() : CHarvesterPlugin(), iPropDefs( NULL )

    {

    }

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

// 2nd phase constructor

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

//

void CHarvesterRtpPlugin::ConstructL()

    {

    WRITELOG( "CHarvesterRtpPlugin::ConstructL()" );

    SetPriority( KHarvesterPriorityHarvestingPlugin - 1 );

    }

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

// Constructor

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

//

CHarvesterRtpPlugin* CHarvesterRtpPlugin::NewL()

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// Destructor

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

//

CHarvesterRtpPlugin::~CHarvesterRtpPlugin()

    {

    WRITELOG( "CHarvesterRtpPlugin::~CHarvesterRtpPlugin()" );

    }

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

// Harvest file

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

//

void CHarvesterRtpPlugin::HarvestL( CHarvesterData* aHD )    

    {

    WRITELOG( "CHarvesterRtpPlugin::Harvest()" );

    CMdEObject& mdeObject = aHD->MdeObject();

    CHarvesterRtpClipDetails* clipDetails = CHarvesterRtpClipDetails::NewL();

    CleanupStack::PushL( clipDetails );

    TRAPD( error, GatherDataL( mdeObject, *clipDetails ) );

    if ( error == KErrNone || error == KErrCompletion )

    	{

    	TBool isNewObject( mdeObject.Id() == 0 );

        if ( isNewObject || mdeObject.Placeholder() )

            {

            TRAP( error, HandleObjectPropertiesL( *aHD, *clipDetails, ETrue ) );

            mdeObject.SetPlaceholder( EFalse );

            }

        else

            {

            TRAP( error, HandleObjectPropertiesL( *aHD, *clipDetails, EFalse ) );

            }

        if ( error != KErrNone )

            {

            WRITELOG1( "CHarvesterWMVPlugin::HarvestL() - Handling object failed: ", error );

            }

    	}

    else

        {

        TInt convertedError = KErrNone;

        MdsUtils::ConvertTrapError( error, convertedError );

        aHD->SetErrorCode( convertedError );

        }

    CleanupStack::PopAndDestroy( clipDetails );

    }

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

// CHarvesterAudioPlugin::GetMimeType (from CHarvesterPlugin)

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

//    

void CHarvesterRtpPlugin::GetMimeType( const TDesC& /*aUri*/, TDes& aMimeType )

    {

    aMimeType = KRtpClipMimetype;

    }

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

// Gather metadata

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

//

void CHarvesterRtpPlugin::GatherDataL( CMdEObject& aMetadataObject, CHarvesterRtpClipDetails& aClipDetails )

    {

    WRITELOG( "CHarvesterRtpPlugin - GatherDataL()" );

    const TDesC& uri = aMetadataObject.Uri();

    HBufC8* buffer = HBufC8::NewLC( KFileBufferSize );

    TPtr8 bufferPtr( buffer->Des() );

    RFile64 file;

    CleanupClosePushL( file );

    User::LeaveIfError( file.Open( iFs, uri, EFileShareAny ) );

    TEntry* entry = new (ELeave) TEntry();

    CleanupStack::PushL( entry );

    User::LeaveIfError( iFs.Entry( uri, *entry ) );

    aClipDetails.iFileSize = (TUint)entry->iSize;

    aClipDetails.iModifiedDate = entry->iModified;

    CleanupStack::PopAndDestroy( entry ); // entry

    User::LeaveIfError( file.Read( bufferPtr, KFileBufferSize ) );

    User::LeaveIfError( RecognizeFile( uri, *buffer, aClipDetails ) );

    User::LeaveIfError( CheckIfMimeSupported( aClipDetails.iMimeType ) ); 

    CHarvesterRtpMetaDataReader* mdr = CHarvesterRtpMetaDataReader::NewL( buffer );

    CleanupStack::PushL( mdr );

    WRITELOG( "CHarvesterRtpPlugin - GatherDataL() ---> found metadata!" );

    mdr->GetClipDetailsL( aClipDetails );

    CleanupStack::PopAndDestroy( mdr ); // mdr

    CleanupStack::PopAndDestroy( &file );  // file

    CleanupStack::PopAndDestroy( buffer ); // buffer

    }

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

// Runs recognizers on the given file to determine its mime type

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

//

TInt CHarvesterRtpPlugin::RecognizeFile(

    const TDesC& aFilePath,

    const TDesC8& aFileBuffer,

    CHarvesterRtpClipDetails& aClipDetails )

    {

    WRITELOG( "CHarvesterRtpPlugin::RecognizeFile()" );

    TInt err( KErrNone );

    RApaLsSession apaSession;

    err = apaSession.Connect();

    if ( err == KErrNone )

        {

        TDataRecognitionResult result;

        err = apaSession.RecognizeData( aFilePath, aFileBuffer, result );

        if ( result.iConfidence >= CApaDataRecognizerType::EProbable )

            {

            aClipDetails.iMimeType = result.iDataType.Des();

            WRITELOG1( "CHarvesterRtpPlugin - Mime type: %S", &aClipDetails.iMimeType );

            }

        apaSession.Close();

        }

    return err;

    }

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

/// Check if mime type is supported

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

//

TInt CHarvesterRtpPlugin::CheckIfMimeSupported( const TDesC& aMimeBuf )

    {

    if ( MdsUtils::Compare( KRtpClipMimetype, aMimeBuf ) == 0 )

        {

        WRITELOG( "CHarvesterRtpPlugin - Mime type supported");

        return KErrNone;

        }

    WRITELOG( "CHarvesterRtpPlugin - Mime type not supported");

    return KErrNotSupported;

    }

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

// Add object properties

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

//

void CHarvesterRtpPlugin::HandleObjectPropertiesL( 

    CHarvesterData& aHD,

    CHarvesterRtpClipDetails& aClipDetails,

    TBool aIsAdd)

    {

    WRITELOG( "CHarvesterRtpPlugin::HandleObjectPropertiesL()" );

    CMdEObject& mdeObject = aHD.MdeObject();

    if( !iPropDefs )

		{

		CMdEObjectDef& objectDef = mdeObject.Def();

		iPropDefs = CHarvesterRtpPluginPropertyDefs::NewL( objectDef );

		}

    TTimeIntervalSeconds timeOffset = User::UTCOffset();

    TTime localModifiedTime = aClipDetails.iModifiedDate + timeOffset;

    if( ! mdeObject.Placeholder() )

    	{

    	// Creation date of media file

    	CMdeObjectWrapper::HandleObjectPropertyL(mdeObject, 

    			*iPropDefs->iCreationDatePropertyDef, &localModifiedTime, aIsAdd );

    	// Last modified date

    	CMdeObjectWrapper::HandleObjectPropertyL(mdeObject, 

    			*iPropDefs->iLastModifiedDatePropertyDef, &aClipDetails.iModifiedDate, aIsAdd );

    	// File size

    	CMdeObjectWrapper::HandleObjectPropertyL(mdeObject, 

    			*iPropDefs->iSizePropertyDef, &aClipDetails.iFileSize, aIsAdd );

        // Mime Type

        CMdeObjectWrapper::HandleObjectPropertyL(mdeObject, 

                *iPropDefs->iItemTypePropertyDef, &aClipDetails.iMimeType, aIsAdd );

    	}

    // Title (is set from URI by default)

    if ( aClipDetails.iTitle.Length() > 0 ) 

        {

        CMdeObjectWrapper::HandleObjectPropertyL(mdeObject, 

        		*iPropDefs->iTitlePropertyDef, &aClipDetails.iTitle, EFalse );

        }

    // Capture date

    CMdeObjectWrapper::HandleObjectPropertyL(mdeObject, 

    		*iPropDefs->iCaptureDatePropertyDef, &localModifiedTime, aIsAdd );    

   	// Duration

    CMdeObjectWrapper::HandleObjectPropertyL(mdeObject, 

    		*iPropDefs->iDurationPropertyDef, &aClipDetails.iDuration, aIsAdd );

    //Save these if video center videostorage available

    //AgeProfile

    CMdeObjectWrapper::HandleObjectPropertyL(mdeObject, 

    		*iPropDefs->iAgeProfilePropertyDef, &aClipDetails.iParental, aIsAdd );

    //VideoFlags    

    TUint32 flags = 0;

    //always set clip type as recording

    flags |= EIptvMyVideosVideoTypeRecording;

    if ( aClipDetails.iRecOngoing )

        {

        //Recording ongoing 

        //Otherwise assuming that recording has completed

        flags |= EIptvMyVideosVideoIsRecording;

        }        

    if ( aClipDetails.iRecFailed )

        {

        //Recording failed

        flags |= EIptvMyVideosVideoRecFailed;

        }

    if ( aClipDetails.iQuality <= KPartiallyFailedLimit )

        {

        //Clip partially failed

        flags |= EIptvMyVideosVideoRecPartiallyFailed;

        }

    CMdeObjectWrapper::HandleObjectPropertyL(mdeObject, 

    		*iPropDefs->iRecordingFlagsPropertyDef, &flags, aIsAdd );

    }