FCL/sf/mw/mmappfw: comparison mmappcomponents/mmmtpdataprovider/src/mmmtpdputility.cpp

equal deleted inserted replaced

-:d45095c2f4f3
+:bee149131e4b
 #include <hxmetadatautil.h>
 #endif
 #include "mmmtpdputility.h"
 #include "mmmtpdpfiledefs.h"
+#include "tobjectdescription.h"
 #include "mmmtpdplogger.h"
 using namespace ContentAccess;
 // local to this file, non standard mimetype used for ASF parsing with helix
 #ifdef __WINDOWS_MEDIA
 if ( file.Ext().CompareF( KTxtExtensionWMA ) == 0 )
 return EMTPFormatCodeWMA;
 #endif // __WINDOWS_MEDIA
-if ( ( file.Ext().CompareF( KTxtExtensionMP4 ) == 0 ) || ( file.Ext().CompareF( KTxtExtensionM4A ) == 0 ) )
+if ( ( file.Ext().CompareF( KTxtExtensionMP4 ) == 0 )
+|| ( file.Ext().CompareF( KTxtExtensionM4A ) == 0 ) )
 return EMTPFormatCodeMP4Container;
-if ( ( file.Ext().CompareF( KTxtExtension3GP ) == 0 ) || ( file.Ext().CompareF( KTxtExtensionO4A ) == 0 ) || ( file.Ext().CompareF( KTxtExtensionO4V ) == 0 ) )
+if ( ( file.Ext().CompareF( KTxtExtension3GP ) == 0 )
+|| ( file.Ext().CompareF( KTxtExtensionO4A ) == 0 )
+|| ( file.Ext().CompareF( KTxtExtensionO4V ) == 0 ) )
 return EMTPFormatCode3GPContainer;
 if ( file.Ext().CompareF( KTxtExtensionAAC ) == 0 )
 return EMTPFormatCodeAAC;
 if ( file.Ext().CompareF( KTxtExtensionWAV ) == 0 )
 return EMTPFormatCodeWAV;
 #ifdef __WINDOWS_MEDIA
 if ( file.Ext().CompareF( KTxtExtensionWMV ) == 0 )
 return EMTPFormatCodeWMV;
 if ( file.Ext().CompareF( KTxtExtensionASF ) == 0 )
 return EMTPFormatCodeASF;
 #endif // __WINDOWS_MEDIA
 return EFalse;
 }
 // -----------------------------------------------------------------------------
+// MmMtpDpUtility::HasReference
+// Utility function to decide if there is any reference
+// -----------------------------------------------------------------------------
+//
+TBool MmMtpDpUtility::HasReference( TUint16 aObjFormatCode )
+{
+if ( aObjFormatCode == EMTPFormatCodeAbstractAudioAlbum
+|| aObjFormatCode == EMTPFormatCodeAbstractAudioVideoPlaylist
+|| aObjFormatCode == EMTPFormatCodeM3UPlaylist )
+return ETrue;
+else
+return EFalse;
+}
+// -----------------------------------------------------------------------------
 // MmMtpDpUtility::IsVideoL (Slow Version)
 // Utility function to determine whether a format is Video or not
 // -----------------------------------------------------------------------------
 //
 EXPORT_C TBool MmMtpDpUtility::IsVideoL( const TDesC& aFullFileName )
 {
 return ETrue;
 }
 else if ( ext.CompareF( KTxtExtensionMP4 ) == 0
 || ext.CompareF( KTxtExtension3GP ) == 0
 || ext.CompareF( KTxtExtensionODF ) == 0
 || ext.CompareF( KTxtExtensionASF ) == 0 )
 {
 HBufC8* mimetype = ContainerMimeType( aFullFileName );
 User::LeaveIfNull( mimetype );
 CleanupStack::PushL( mimetype ); // + mimetype
 TMmMtpSubFormatCode subFormatCode;
 User::LeaveIfError( SubFormatCodeFromMime( *mimetype, subFormatCode ) );
 CleanupStack::PopAndDestroy( mimetype ); // - mimetype
 if ( subFormatCode == EMTPSubFormatCodeVideo )
 {
 return ETrue;
 }
 else
 {
 return EFalse;
 }
 }
 else if ( ext.CompareF( KTxtExtensionO4V ) == 0 )
 return ETrue;
 // other format, as audio
 return EFalse;
 // -----------------------------------------------------------------------------
 // MmMtpDpUtility::IsVideoL (Fast Version)
 // Utility function to determine whether a format is Video or not
 // -----------------------------------------------------------------------------
 //
 TBool MmMtpDpUtility::IsVideoL( const TDesC& aFullFileName,
 const MMTPDataProviderFramework& aFramework )
 {
 PRINT1( _L( "MM MTP => MmMtpDpUtility::IsVideoL (Fast Version) aFullFileName = %S" ), &aFullFileName );
 CMTPObjectMetaData* info = CMTPObjectMetaData::NewLC(); // + info
 aFramework.ObjectMgr().ObjectL( aFullFileName, *info );
 TUint formatCode = info->Uint( CMTPObjectMetaData::EFormatCode );
 TUint subFormatCode = info->Uint( CMTPObjectMetaData::EFormatSubCode );
 CleanupStack::PopAndDestroy( info ); // - info
-if ( formatCode == EMTPFormatCodeWMV )
+return MmMtpDpUtility::IsVideoL( formatCode, subFormatCode );
+}
+// -----------------------------------------------------------------------------
+// MmMtpDpUtility::IsVideoL (Fast Version)
+// Utility function to determine whether a format is Video or not
+// -----------------------------------------------------------------------------
+//
+TBool MmMtpDpUtility::IsVideoL( TUint aFormatCode, TUint aSubFormatCode )
+{
+if ( aFormatCode == KMTPFormatsAll )
+User::Leave( KErrArgument );
+if ( aFormatCode == EMTPFormatCodeWMV )
 {
 return ETrue;
 }
-else if ( ( formatCode == EMTPFormatCodeMP4Container )
+else if ( ( aFormatCode == EMTPFormatCodeMP4Container )
-|| ( formatCode == EMTPFormatCode3GPContainer )
+|| ( aFormatCode == EMTPFormatCode3GPContainer )
-|| ( formatCode == EMTPFormatCodeASF ) )
+|| ( aFormatCode == EMTPFormatCodeASF ) )
 {
-if ( subFormatCode == EMTPSubFormatCodeAudio )
+if ( aSubFormatCode == EMTPSubFormatCodeAudio )
 {
 return EFalse;
 }
-else if ( subFormatCode == EMTPSubFormatCodeVideo )
+else if ( aSubFormatCode == EMTPSubFormatCodeVideo )
 {
 return ETrue;
 }
 }
 TUint64 MmMtpDpUtility::GetObjectSizeL( RFs& aFs, const TDesC& aFileName )
 {
 TEntry fileInfo;
 // Shouldn't leave
 User::LeaveIfError( aFs.Entry( aFileName, fileInfo ) );
-return fileInfo.iSize;
+return fileInfo.FileSize();
 }
 // -----------------------------------------------------------------------------
 // MmMtpDpUtility::GetDateModifiedL
 // Get the file date modified.
 if ( fileInfo.IsReadOnly() )
 {
 protectionStatus = EMTPProtectionReadOnly;
 }
+PRINT2( _L( "MM MTP <> MmMtpDpUtility::GetProtectionStatusL aFullFileName = %S, protectionStatus = 0x%x" ),
+&aFullFileName,
+protectionStatus );
 return protectionStatus;
 }
 // -----------------------------------------------------------------------------
 // MmMtpDpUtility::CheckPropType
 // Check if property type match datatype.
 // -----------------------------------------------------------------------------
 //
 TMTPResponseCode MmMtpDpUtility::CheckPropType(TUint16 aPropertyCode, TUint16 aDataType)
 {
 PRINT2( _L( "MM MTP => MmMtpDpUtility::CheckPropCode aPropertyCode = 0x%x, aDataType = 0x%x" ),
 aPropertyCode,
 aDataType );
 TMTPResponseCode responseCode = EMTPRespCodeOK;
 switch ( aPropertyCode )
 {
 case EMTPObjectPropCodeParentObject:
 case EMTPObjectPropCodePersistentUniqueObjectIdentifier:
 case EMTPObjectPropCodeDateCreated:
 case EMTPObjectPropCodeDateModified:
 case EMTPObjectPropCodeDateAdded:
-case EMTPObjectPropCodeNonConsumable:
 case EMTPObjectPropCodeVideoBitRate:
 {
 responseCode = EMTPRespCodeAccessDenied;
 }
 break;
 responseCode = EMTPRespCodeInvalidObjectPropFormat;
 }
 }
 break;
+// Uint8 properties
+case EMTPObjectPropCodeNonConsumable:
+case EMTPExtObjectPropCodeOmaDrmStatus: // 0xDB01
+{
+if ( aDataType != EMTPTypeUINT8 )
+{
+responseCode = EMTPRespCodeInvalidObjectPropFormat;
+}
+}
+break;
 default:
 {
 responseCode = EMTPRespCodeInvalidObjectPropCode;
 }
 break;
 }
 PRINT1( _L( "MM MTP <= MmMtpDpUtility::CheckPropCode responseCode = 0x%x" ),
 responseCode );
 return responseCode;
 }
 // -----------------------------------------------------------------------------
 aNewName.Insert( 0, ptr );
 }
 return aFs.Rename( aFullFileName, aNewName );
 }
 // -----------------------------------------------------------------------------
 // MetadataAccessWrapper::ContainerMimeType
 // Get mime type from file
 // -----------------------------------------------------------------------------
 //
 {
 TRAP( err, mimebuf = AsfMimeTypeL( aFullPath ) );
 PRINT1( _L("MM MTP <> MmMtpDpUtility::ContainerMimeType, AsfMimeTypeL err = %d"), err );
 }
 #endif
 PRINT( _L( "MM MTP <= MmMtpDpUtility::ContainerMimeType" ) );
 return mimebuf;
 }
 // -----------------------------------------------------------------------------
 HBufC8* MmMtpDpUtility::Mp4MimeTypeL( const TDesC& aFullPath )
 {
 PRINT( _L( "MM MTP => MmMtpDpUtility::Mp4MimeTypeL" ) );
 HBufC8* mimebuf = NULL;
 TParsePtrC file( aFullPath );
 if ( file.Ext().CompareF( KTxtExtensionMP4 ) == 0
 || file.Ext().CompareF( KTxtExtension3GP ) == 0 )
 {
 // get mime from file
 MP4Handle mp4Handle = NULL;
 }
 else
 {
 User::Leave( KErrNotSupported );
 }
 if ( mimebuf == NULL )
 {
 User::Leave( KErrNotFound );
 }
 PRINT( _L( "MM MTP <= MmMtpDpUtility::Mp4MimeTypeL" ) );
 //
 HBufC8* MmMtpDpUtility::OdfMimeTypeL( const TDesC& aFullPath )
 {
 PRINT( _L( "MM MTP => MmMtpDpUtility::OdfMimeTypeL" ) );
 HBufC8* mimebuf = NULL;
 TParsePtrC file( aFullPath );
 if ( file.Ext().CompareF( KTxtExtensionODF ) == 0 )
 {
 CContent* content = CContent::NewL( aFullPath );
 CleanupStack::PushL( content ); // + content
 HBufC* buffer = HBufC::NewL( KMimeTypeMaxLength );
 CleanupStack::PushL( buffer ); // + buffer
 TPtr data = buffer->Des();
 TInt err = content->GetStringAttribute( EMimeType, data );
 if ( err == KErrNone )
 {
 mimebuf = HBufC8::New( buffer->Length() );
 if (mimebuf == NULL)
 {
 User::LeaveIfError( KErrNotFound );
 }
 mimebuf->Des().Copy( *buffer );
 }
 // leave if NULL
 if ( mimebuf == NULL )
 {
 User::Leave( KErrNotFound );
 }
 CleanupStack::PopAndDestroy( buffer ); // - buffer
 CleanupStack::PopAndDestroy( content ); // - content
 }
 else
 {
 User::Leave( KErrNotSupported );
 }
 PRINT( _L( "MM MTP <= MmMtpDpUtility::OdfMimeTypeL" ) );
 return mimebuf;
 }
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 //
 HBufC8* MmMtpDpUtility::AsfMimeTypeL( const TDesC& aFullPath )
 {
 PRINT( _L( "MM MTP => MmMtpDpUtility::AsfMimeTypeL" ) );
 HBufC8* mimebuf = NULL;
 #ifdef __WINDOWS_MEDIA
 TParsePtrC file( aFullPath );
 if ( file.Ext().CompareF( KTxtExtensionASF ) == 0 )
 {
 CHXMetaDataUtility *hxUtility = CHXMetaDataUtility::NewL();
 CleanupStack::PushL( hxUtility );
 hxUtility->OpenFileL( aFullPath );
 HXMetaDataKeys::EHXMetaDataId id;
 TUint count = 0;
 TBool isAudio = EFalse;
 hxUtility->GetMetaDataCount( count );
 for ( TUint i = 0; i < count; i++ )
 {
 HBufC* buf = NULL;
 hxUtility->GetMetaDataAt( i, id, buf );
 if ( id == HXMetaDataKeys::EHXMimeType )
 {
 TPtr des = buf->Des();
 if ( des.Find( KHxMimeTypeWma() ) != KErrNotFound )
 {
 isAudio = ETrue;
 }
 else if ( des.Find( KHxMimeTypeWmv() ) != KErrNotFound )
 }
 }
 }
 hxUtility->ResetL();
 CleanupStack::PopAndDestroy( hxUtility );
 }
 else
 {
 User::Leave( KErrNotSupported );
 }
 #else
 User::Leave( KErrNotSupported );
 #endif
 PRINT( _L( "MM MTP <= MmMtpDpUtility::AsfMimeTypeL" ) );
 return mimebuf;
 }
 // -----------------------------------------------------------------------------
 // MetadataAccessWrapper::SubFormatCodeFromMime
 // Get subformat code from mime string
 // -----------------------------------------------------------------------------
 //
 TInt MmMtpDpUtility::SubFormatCodeFromMime( const TDesC8& aMimeType,
 TMmMtpSubFormatCode& aSubFormatCode )
 {
 PRINT( _L( "MM MTP => MmMtpDpUtility::SubFormatCodeFromMime" ) );
 if ( aMimeType.CompareF( KMimeTypeVideoMp4 ) == 0
 content = NULL;
 }
 }
 PRINT1( _L( "MM MTP <= MmMtpDpUtility::GetDrmStatus, drmStatus: %d" ), drmStatus );
 return drmStatus;
 }
-//end of file
+// end of file

branch	RCL_3
changeset 9	bee149131e4b
parent 0	a2952bb97e68
child 14	05b0d2323768